AOMedia AV1 Codec
encoder.h
Go to the documentation of this file.
1/*
2 * Copyright (c) 2016, Alliance for Open Media. All rights reserved.
3 *
4 * This source code is subject to the terms of the BSD 2 Clause License and
5 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
6 * was not distributed with this source code in the LICENSE file, you can
7 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
8 * Media Patent License 1.0 was not distributed with this source code in the
9 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
10 */
11
15#ifndef AOM_AV1_ENCODER_ENCODER_H_
16#define AOM_AV1_ENCODER_ENCODER_H_
17
18#include <stdbool.h>
19#include <stdio.h>
20
21#include "config/aom_config.h"
22
23#include "aom/aomcx.h"
24#include "aom_util/aom_pthread.h"
25
26#include "av1/common/alloccommon.h"
27#include "av1/common/av1_common_int.h"
28#include "av1/common/blockd.h"
29#include "av1/common/entropymode.h"
30#include "av1/common/enums.h"
31#include "av1/common/reconintra.h"
32#include "av1/common/resize.h"
33#include "av1/common/thread_common.h"
34#include "av1/common/timing.h"
35
36#include "av1/encoder/aq_cyclicrefresh.h"
37#include "av1/encoder/av1_quantize.h"
38#include "av1/encoder/block.h"
39#include "av1/encoder/context_tree.h"
40#include "av1/encoder/enc_enums.h"
41#include "av1/encoder/encodemb.h"
42#include "av1/encoder/external_partition.h"
43#include "av1/encoder/firstpass.h"
44#include "av1/encoder/global_motion.h"
45#include "av1/encoder/level.h"
47#include "av1/encoder/mcomp.h"
48#include "av1/encoder/pickcdef.h"
49#include "av1/encoder/ratectrl.h"
50#include "av1/encoder/rd.h"
52#include "av1/encoder/svc_layercontext.h"
53#include "av1/encoder/temporal_filter.h"
54#if CONFIG_THREE_PASS
55#include "av1/encoder/thirdpass.h"
56#endif
57#include "av1/encoder/tokenize.h"
58#include "av1/encoder/tpl_model.h"
59#include "av1/encoder/av1_noise_estimate.h"
60#include "av1/encoder/bitstream.h"
61
62#if CONFIG_INTERNAL_STATS
63#include "aom_dsp/ssim.h"
64#endif
65#include "aom_dsp/variance.h"
66#if CONFIG_DENOISE
67#include "aom_dsp/noise_model.h"
68#endif
69#if CONFIG_TUNE_VMAF
70#include "av1/encoder/tune_vmaf.h"
71#endif
72#if CONFIG_AV1_TEMPORAL_DENOISING
73#include "av1/encoder/av1_temporal_denoiser.h"
74#endif
75#if CONFIG_TUNE_BUTTERAUGLI
76#include "av1/encoder/tune_butteraugli.h"
77#endif
78
79#include "aom/internal/aom_codec_internal.h"
80
81#ifdef __cplusplus
82extern "C" {
83#endif
84
85// TODO(yunqing, any): Added suppression tag to quiet Doxygen warnings. Need to
86// adjust it while we work on documentation.
88// Number of frames required to test for scene cut detection
89#define SCENE_CUT_KEY_TEST_INTERVAL 16
90
91// Lookahead index threshold to enable temporal filtering for second arf.
92#define TF_LOOKAHEAD_IDX_THR 7
93
94#define HDR_QP_LEVELS 10
95#define CHROMA_CB_QP_SCALE 1.04
96#define CHROMA_CR_QP_SCALE 1.04
97#define CHROMA_QP_SCALE -0.46
98#define CHROMA_QP_OFFSET 9.26
99#define QP_SCALE_FACTOR 2.0
100#define DISABLE_HDR_LUMA_DELTAQ 1
101
102// Rational number with an int64 numerator
103// This structure holds a fractional value
104typedef struct aom_rational64 {
105 int64_t num; // fraction numerator
106 int den; // fraction denominator
107} aom_rational64_t; // alias for struct aom_rational
108
109enum {
110 // Good Quality Fast Encoding. The encoder balances quality with the amount of
111 // time it takes to encode the output. Speed setting controls how fast.
112 GOOD,
113 // Realtime Fast Encoding. Will force some restrictions on bitrate
114 // constraints.
115 REALTIME,
116 // All intra mode. All the frames are coded as intra frames.
117 ALLINTRA
118} UENUM1BYTE(MODE);
119
120enum {
121 FRAMEFLAGS_KEY = 1 << 0,
122 FRAMEFLAGS_GOLDEN = 1 << 1,
123 FRAMEFLAGS_BWDREF = 1 << 2,
124 // TODO(zoeliu): To determine whether a frame flag is needed for ALTREF2_FRAME
125 FRAMEFLAGS_ALTREF = 1 << 3,
126 FRAMEFLAGS_INTRAONLY = 1 << 4,
127 FRAMEFLAGS_SWITCH = 1 << 5,
128 FRAMEFLAGS_ERROR_RESILIENT = 1 << 6,
129} UENUM1BYTE(FRAMETYPE_FLAGS);
130
131#if CONFIG_FPMT_TEST
132enum {
133 PARALLEL_ENCODE = 0,
134 PARALLEL_SIMULATION_ENCODE,
135 NUM_FPMT_TEST_ENCODES
136} UENUM1BYTE(FPMT_TEST_ENC_CFG);
137#endif // CONFIG_FPMT_TEST
138// 0 level frames are sometimes used for rate control purposes, but for
139// reference mapping purposes, the minimum level should be 1.
140#define MIN_PYR_LEVEL 1
141static inline int get_true_pyr_level(int frame_level, int frame_order,
142 int max_layer_depth) {
143 if (frame_order == 0) {
144 // Keyframe case
145 return MIN_PYR_LEVEL;
146 } else if (frame_level == MAX_ARF_LAYERS) {
147 // Leaves
148 return max_layer_depth;
149 } else if (frame_level == (MAX_ARF_LAYERS + 1)) {
150 // Altrefs
151 return MIN_PYR_LEVEL;
152 }
153 return AOMMAX(MIN_PYR_LEVEL, frame_level);
154}
155
156enum {
157 NO_AQ = 0,
158 VARIANCE_AQ = 1,
159 COMPLEXITY_AQ = 2,
160 CYCLIC_REFRESH_AQ = 3,
161 AQ_MODE_COUNT // This should always be the last member of the enum
162} UENUM1BYTE(AQ_MODE);
163enum {
164 NO_DELTA_Q = 0,
165 DELTA_Q_OBJECTIVE = 1, // Modulation to improve objective quality
166 DELTA_Q_PERCEPTUAL = 2, // Modulation to improve video perceptual quality
167 DELTA_Q_PERCEPTUAL_AI = 3, // Perceptual quality opt for all intra mode
168 DELTA_Q_USER_RATING_BASED = 4, // User rating based delta q mode
169 DELTA_Q_HDR = 5, // QP adjustment based on HDR block pixel average
170 DELTA_Q_VARIANCE_BOOST =
171 6, // Variance Boost style modulation for all intra mode
172 DELTA_Q_MODE_COUNT // This should always be the last member of the enum
173} UENUM1BYTE(DELTAQ_MODE);
174
175enum {
176 RESIZE_NONE = 0, // No frame resizing allowed.
177 RESIZE_FIXED = 1, // All frames are coded at the specified scale.
178 RESIZE_RANDOM = 2, // All frames are coded at a random scale.
179 RESIZE_DYNAMIC = 3, // Frames coded at lower scale based on rate control.
180 RESIZE_MODES
181} UENUM1BYTE(RESIZE_MODE);
182
183enum {
184 SS_CFG_SRC = 0,
185 SS_CFG_LOOKAHEAD = 1,
186 SS_CFG_FPF = 2,
187 SS_CFG_TOTAL = 3
188} UENUM1BYTE(SS_CFG_OFFSET);
189
190enum {
191 DISABLE_SCENECUT, // For LAP, lag_in_frames < 19
192 ENABLE_SCENECUT_MODE_1, // For LAP, lag_in_frames >=19 and < 33
193 ENABLE_SCENECUT_MODE_2 // For twopass and LAP - lag_in_frames >=33
194} UENUM1BYTE(SCENECUT_MODE);
195
196#define MAX_VBR_CORPUS_COMPLEXITY 10000
197
198typedef enum {
199 MOD_FP, // First pass
200 MOD_TF, // Temporal filtering
201 MOD_TPL, // TPL
202 MOD_GME, // Global motion estimation
203 MOD_ENC, // Encode stage
204 MOD_LPF, // Deblocking loop filter
205 MOD_CDEF_SEARCH, // CDEF search
206 MOD_CDEF, // CDEF frame
207 MOD_LR, // Loop restoration filtering
208 MOD_PACK_BS, // Pack bitstream
209 MOD_FRAME_ENC, // Frame Parallel encode
210 MOD_AI, // All intra
211 NUM_MT_MODULES
212} MULTI_THREADED_MODULES;
213
215
229
240
245typedef enum {
246 SKIP_APPLY_RESTORATION = 1 << 0,
247 SKIP_APPLY_SUPERRES = 1 << 1,
248 SKIP_APPLY_CDEF = 1 << 2,
249 SKIP_APPLY_LOOPFILTER = 1 << 3,
251
255typedef struct {
259 RESIZE_MODE resize_mode;
270} ResizeCfg;
271
299
354
396
427
463
467typedef struct {
472
477
482
488
495
500
505
510
515
521
635
637typedef struct {
638 // Indicates the number of frames lag before encoding is started.
639 int lag_in_frames;
640 // Indicates the minimum gf/arf interval to be used.
641 int min_gf_interval;
642 // Indicates the maximum gf/arf interval to be used.
643 int max_gf_interval;
644 // Indicates the minimum height for GF group pyramid structure to be used.
645 int gf_min_pyr_height;
646 // Indicates the maximum height for GF group pyramid structure to be used.
647 int gf_max_pyr_height;
648 // Indicates if automatic set and use of altref frames should be enabled.
649 bool enable_auto_arf;
650 // Indicates if automatic set and use of (b)ackward (r)ef (f)rames should be
651 // enabled.
652 bool enable_auto_brf;
653} GFConfig;
654
655typedef struct {
656 // Indicates the number of tile groups.
657 unsigned int num_tile_groups;
658 // Indicates the MTU size for a tile group. If mtu is non-zero,
659 // num_tile_groups is set to DEFAULT_MAX_NUM_TG.
660 unsigned int mtu;
661 // Indicates the number of tile columns in log2.
662 int tile_columns;
663 // Indicates the number of tile rows in log2.
664 int tile_rows;
665 // Indicates the number of widths in the tile_widths[] array.
666 int tile_width_count;
667 // Indicates the number of heights in the tile_heights[] array.
668 int tile_height_count;
669 // Indicates the tile widths, and may be empty.
670 int tile_widths[MAX_TILE_COLS];
671 // Indicates the tile heights, and may be empty.
672 int tile_heights[MAX_TILE_ROWS];
673 // Indicates if large scale tile coding should be used.
674 bool enable_large_scale_tile;
675 // Indicates if single tile decoding mode should be enabled.
676 bool enable_single_tile_decoding;
677 // Indicates if EXT_TILE_DEBUG should be enabled.
678 bool enable_ext_tile_debug;
679} TileConfig;
680
681typedef struct {
682 // Indicates the width of the input frame.
683 int width;
684 // Indicates the height of the input frame.
685 int height;
686 // If forced_max_frame_width is non-zero then it is used to force the maximum
687 // frame width written in write_sequence_header().
688 int forced_max_frame_width;
689 // If forced_max_frame_width is non-zero then it is used to force the maximum
690 // frame height written in write_sequence_header().
691 int forced_max_frame_height;
692 // Indicates the frame width after applying both super-resolution and resize
693 // to the coded frame.
694 int render_width;
695 // Indicates the frame height after applying both super-resolution and resize
696 // to the coded frame.
697 int render_height;
698} FrameDimensionCfg;
699
700typedef struct {
701 // Indicates if warped motion should be enabled.
702 bool enable_warped_motion;
703 // Indicates if warped motion should be evaluated or not.
704 bool allow_warped_motion;
705 // Indicates if OBMC motion should be enabled.
706 bool enable_obmc;
707} MotionModeCfg;
708
709typedef struct {
710 // Timing info for each frame.
711 aom_timing_info_t timing_info;
712 // Indicates the number of time units of a decoding clock.
713 uint32_t num_units_in_decoding_tick;
714 // Indicates if decoder model information is present in the coded sequence
715 // header.
716 bool decoder_model_info_present_flag;
717 // Indicates if display model information is present in the coded sequence
718 // header.
719 bool display_model_info_present_flag;
720 // Indicates if timing info for each frame is present.
721 bool timing_info_present;
722} DecoderModelCfg;
723
724typedef struct {
725 // Indicates the update frequency for coeff costs.
726 COST_UPDATE_TYPE coeff;
727 // Indicates the update frequency for mode costs.
728 COST_UPDATE_TYPE mode;
729 // Indicates the update frequency for mv costs.
731 // Indicates the update frequency for dv costs.
733} CostUpdateFreq;
734
735typedef struct {
736 // Indicates the maximum number of reference frames allowed per frame.
737 unsigned int max_reference_frames;
738 // Indicates if the reduced set of references should be enabled.
739 bool enable_reduced_reference_set;
740 // Indicates if one-sided compound should be enabled.
741 bool enable_onesided_comp;
742} RefFrameCfg;
743
744typedef struct {
745 // Indicates the color space that should be used.
746 aom_color_primaries_t color_primaries;
747 // Indicates the characteristics of transfer function to be used.
748 aom_transfer_characteristics_t transfer_characteristics;
749 // Indicates the matrix coefficients to be used for the transfer function.
750 aom_matrix_coefficients_t matrix_coefficients;
751 // Indicates the chroma 4:2:0 sample position info.
752 aom_chroma_sample_position_t chroma_sample_position;
753 // Indicates if a limited color range or full color range should be used.
754 aom_color_range_t color_range;
755} ColorCfg;
756
757typedef struct {
758 // Indicates if extreme motion vector unit test should be enabled or not.
759 unsigned int motion_vector_unit_test;
760 // Indicates if superblock multipass unit test should be enabled or not.
761 unsigned int sb_multipass_unit_test;
762} UnitTestCfg;
763
764typedef struct {
765 // Indicates the file path to the VMAF model.
766 const char *vmaf_model_path;
767 // Indicates the path to the film grain parameters.
768 const char *film_grain_table_filename;
769 // Indicates the visual tuning metric.
770 aom_tune_metric tuning;
771 // Indicates if the current content is screen or default type.
772 aom_tune_content content;
773 // Indicates the film grain parameters.
774 int film_grain_test_vector;
775 // Indicates the in-block distortion metric to use.
776 aom_dist_metric dist_metric;
777} TuneCfg;
778
779typedef struct {
780 // Indicates the framerate of the input video.
781 double init_framerate;
782 // Indicates the bit-depth of the input video.
783 unsigned int input_bit_depth;
784 // Indicates the maximum number of frames to be encoded.
785 unsigned int limit;
786 // Indicates the chrome subsampling x value.
787 unsigned int chroma_subsampling_x;
788 // Indicates the chrome subsampling y value.
789 unsigned int chroma_subsampling_y;
790} InputCfg;
791
792typedef struct {
793 // If true, encoder will use fixed QP offsets, that are either:
794 // - Given by the user, and stored in 'fixed_qp_offsets' array, OR
795 // - Picked automatically from cq_level.
796 int use_fixed_qp_offsets;
797 // Indicates the minimum flatness of the quantization matrix.
798 int qm_minlevel;
799 // Indicates the maximum flatness of the quantization matrix.
800 int qm_maxlevel;
801 // Indicates if adaptive quantize_b should be enabled.
802 int quant_b_adapt;
803 // Indicates the Adaptive Quantization mode to be used.
804 AQ_MODE aq_mode;
805 // Indicates the delta q mode to be used.
806 DELTAQ_MODE deltaq_mode;
807 // Indicates the delta q mode strength.
808 DELTAQ_MODE deltaq_strength;
809 // Indicates if delta quantization should be enabled in chroma planes.
810 bool enable_chroma_deltaq;
811 // Indicates if delta quantization should be enabled for hdr video
812 bool enable_hdr_deltaq;
813 // Indicates if encoding with quantization matrices should be enabled.
814 bool using_qm;
815} QuantizationCfg;
816
894
895
896typedef struct {
897 // Indicates the codec bit-depth.
898 aom_bit_depth_t bit_depth;
899 // Indicates the superblock size that should be used by the encoder.
900 aom_superblock_size_t superblock_size;
901 // Indicates if loopfilter modulation should be enabled.
902 bool enable_deltalf_mode;
903 // Indicates how CDEF should be applied.
904 CDEF_CONTROL cdef_control;
905 // Indicates if loop restoration filter should be enabled.
906 bool enable_restoration;
907 // When enabled, video mode should be used even for single frame input.
908 bool force_video_mode;
909 // Indicates if the error resiliency features should be enabled.
910 bool error_resilient_mode;
911 // Indicates if frame parallel decoding feature should be enabled.
912 bool frame_parallel_decoding_mode;
913 // Indicates if the input should be encoded as monochrome.
914 bool enable_monochrome;
915 // When enabled, the encoder will use a full header even for still pictures.
916 // When disabled, a reduced header is used for still pictures.
917 bool full_still_picture_hdr;
918 // Indicates if dual interpolation filters should be enabled.
919 bool enable_dual_filter;
920 // Indicates if frame order hint should be enabled or not.
921 bool enable_order_hint;
922 // Indicates if ref_frame_mvs should be enabled at the sequence level.
923 bool ref_frame_mvs_present;
924 // Indicates if ref_frame_mvs should be enabled at the frame level.
925 bool enable_ref_frame_mvs;
926 // Indicates if interintra compound mode is enabled.
927 bool enable_interintra_comp;
928 // Indicates if global motion should be enabled.
929 bool enable_global_motion;
930 // Indicates if palette should be enabled.
931 bool enable_palette;
932} ToolCfg;
933
938typedef struct AV1EncoderConfig {
940 // Configuration related to the input video.
941 InputCfg input_cfg;
942
943 // Configuration related to frame-dimensions.
944 FrameDimensionCfg frm_dim_cfg;
945
951
956
962
963 // Configuration related to Quantization.
964 QuantizationCfg q_cfg;
965
966 // Internal frame size scaling.
967 ResizeCfg resize_cfg;
968
969 // Frame Super-Resolution size scaling.
970 SuperResCfg superres_cfg;
971
979
980 // Configuration related to encoder toolsets.
981 ToolCfg tool_cfg;
982
983 // Configuration related to Group of frames.
984 GFConfig gf_cfg;
985
986 // Tile related configuration parameters.
987 TileConfig tile_cfg;
988
989 // Configuration related to Tune.
990 TuneCfg tune_cfg;
991
992 // Configuration related to color.
993 ColorCfg color_cfg;
994
995 // Configuration related to decoder model.
996 DecoderModelCfg dec_model_cfg;
997
998 // Configuration related to reference frames.
999 RefFrameCfg ref_frm_cfg;
1000
1001 // Configuration related to unit tests.
1002 UnitTestCfg unit_test_cfg;
1003
1004 // Flags related to motion mode.
1005 MotionModeCfg motion_mode_cfg;
1006
1007 // Flags related to intra mode search.
1008 IntraModeCfg intra_mode_cfg;
1009
1010 // Flags related to transform size/type.
1011 TxfmSizeTypeCfg txfm_cfg;
1012
1013 // Flags related to compound type.
1014 CompoundTypeCfg comp_type_cfg;
1015
1016 // Partition related information.
1017 PartitionCfg part_cfg;
1018
1019 // Configuration related to frequency of cost update.
1020 CostUpdateFreq cost_upd_freq;
1021
1022#if CONFIG_DENOISE
1023 // Indicates the noise level.
1024 float noise_level;
1025 // Indicates the the denoisers block size.
1026 int noise_block_size;
1027 // Indicates whether to apply denoising to the frame to be encoded
1028 int enable_dnl_denoising;
1029#endif
1030
1031#if CONFIG_AV1_TEMPORAL_DENOISING
1032 // Noise sensitivity.
1033 int noise_sensitivity;
1034#endif
1035 // Bit mask to specify which tier each of the 32 possible operating points
1036 // conforms to.
1037 unsigned int tier_mask;
1038
1039 // Indicates the number of pixels off the edge of a reference frame we're
1040 // allowed to go when forming an inter prediction.
1041 int border_in_pixels;
1042
1043 // Indicates the maximum number of threads that may be used by the encoder.
1044 int max_threads;
1045
1046 // Indicates the speed preset to be used.
1047 int speed;
1048
1049 // Enable the low complexity decode mode.
1050 unsigned int enable_low_complexity_decode;
1051
1052 // Indicates the target sequence level index for each operating point(OP).
1053 AV1_LEVEL target_seq_level_idx[MAX_NUM_OPERATING_POINTS];
1054
1055 // Indicates the bitstream profile to be used.
1056 BITSTREAM_PROFILE profile;
1057
1068
1069 // Total number of encoding passes.
1070 int passes;
1071
1072 // the name of the second pass output file when passes > 2
1073 const char *two_pass_output;
1074
1075 // the name of the second pass log file when passes > 2
1076 const char *second_pass_log;
1077
1078 // Indicates if the encoding is GOOD or REALTIME.
1079 MODE mode;
1080
1081 // Indicates if row-based multi-threading should be enabled or not.
1082 bool row_mt;
1083
1084 // Indicates if frame parallel multi-threading should be enabled or not.
1085 bool fp_mt;
1086
1087 // Indicates if 16bit frame buffers are to be used i.e., the content is >
1088 // 8-bit.
1089 bool use_highbitdepth;
1090
1091 // Indicates the bitstream syntax mode. 0 indicates bitstream is saved as
1092 // Section 5 bitstream, while 1 indicates the bitstream is saved in Annex - B
1093 // format.
1094 bool save_as_annexb;
1095
1096 // The path for partition stats reading and writing, used in the experiment
1097 // CONFIG_PARTITION_SEARCH_ORDER.
1098 const char *partition_info_path;
1099
1100 // The flag that indicates whether we use an external rate distribution to
1101 // guide adaptive quantization. It requires --deltaq-mode=3. The rate
1102 // distribution map file name is stored in |rate_distribution_info|.
1103 unsigned int enable_rate_guide_deltaq;
1104
1105 // The input file of rate distribution information used in all intra mode
1106 // to determine delta quantization.
1107 const char *rate_distribution_info;
1108
1109 // Exit the encoder when it fails to encode to a given level.
1110 int strict_level_conformance;
1111
1112 // Max depth for the GOP after a key frame
1113 int kf_max_pyr_height;
1114
1115 // A flag to control if we enable the superblock qp sweep for a given lambda
1116 int sb_qp_sweep;
1119
1121static inline int is_lossless_requested(const RateControlCfg *const rc_cfg) {
1122 return rc_cfg->best_allowed_q == 0 && rc_cfg->worst_allowed_q == 0;
1123}
1125
1129typedef struct {
1135 int obmc_probs[FRAME_UPDATE_TYPES][BLOCK_SIZES_ALL];
1136
1142 int warped_probs[FRAME_UPDATE_TYPES];
1143
1150 int tx_type_probs[FRAME_UPDATE_TYPES][TX_SIZES_ALL][TX_TYPES];
1151
1158 int switchable_interp_probs[FRAME_UPDATE_TYPES][SWITCHABLE_FILTER_CONTEXTS]
1159 [SWITCHABLE_FILTERS];
1161
1163
1164typedef struct FRAME_COUNTS {
1165// Note: This structure should only contain 'unsigned int' fields, or
1166// aggregates built solely from 'unsigned int' fields/elements
1167#if CONFIG_ENTROPY_STATS
1168 unsigned int kf_y_mode[KF_MODE_CONTEXTS][KF_MODE_CONTEXTS][INTRA_MODES];
1169 unsigned int angle_delta[DIRECTIONAL_MODES][2 * MAX_ANGLE_DELTA + 1];
1170 unsigned int y_mode[BLOCK_SIZE_GROUPS][INTRA_MODES];
1171 unsigned int uv_mode[CFL_ALLOWED_TYPES][INTRA_MODES][UV_INTRA_MODES];
1172 unsigned int cfl_sign[CFL_JOINT_SIGNS];
1173 unsigned int cfl_alpha[CFL_ALPHA_CONTEXTS][CFL_ALPHABET_SIZE];
1174 unsigned int palette_y_mode[PALATTE_BSIZE_CTXS][PALETTE_Y_MODE_CONTEXTS][2];
1175 unsigned int palette_uv_mode[PALETTE_UV_MODE_CONTEXTS][2];
1176 unsigned int palette_y_size[PALATTE_BSIZE_CTXS][PALETTE_SIZES];
1177 unsigned int palette_uv_size[PALATTE_BSIZE_CTXS][PALETTE_SIZES];
1178 unsigned int palette_y_color_index[PALETTE_SIZES]
1179 [PALETTE_COLOR_INDEX_CONTEXTS]
1180 [PALETTE_COLORS];
1181 unsigned int palette_uv_color_index[PALETTE_SIZES]
1182 [PALETTE_COLOR_INDEX_CONTEXTS]
1183 [PALETTE_COLORS];
1184 unsigned int partition[PARTITION_CONTEXTS][EXT_PARTITION_TYPES];
1185 unsigned int txb_skip[TOKEN_CDF_Q_CTXS][TX_SIZES][TXB_SKIP_CONTEXTS][2];
1186 unsigned int eob_extra[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1187 [EOB_COEF_CONTEXTS][2];
1188 unsigned int dc_sign[PLANE_TYPES][DC_SIGN_CONTEXTS][2];
1189 unsigned int coeff_lps[TX_SIZES][PLANE_TYPES][BR_CDF_SIZE - 1][LEVEL_CONTEXTS]
1190 [2];
1191 unsigned int eob_flag[TX_SIZES][PLANE_TYPES][EOB_COEF_CONTEXTS][2];
1192 unsigned int eob_multi16[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][5];
1193 unsigned int eob_multi32[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][6];
1194 unsigned int eob_multi64[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][7];
1195 unsigned int eob_multi128[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][8];
1196 unsigned int eob_multi256[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][9];
1197 unsigned int eob_multi512[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][10];
1198 unsigned int eob_multi1024[TOKEN_CDF_Q_CTXS][PLANE_TYPES][2][11];
1199 unsigned int coeff_lps_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1200 [LEVEL_CONTEXTS][BR_CDF_SIZE];
1201 unsigned int coeff_base_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1202 [SIG_COEF_CONTEXTS][NUM_BASE_LEVELS + 2];
1203 unsigned int coeff_base_eob_multi[TOKEN_CDF_Q_CTXS][TX_SIZES][PLANE_TYPES]
1204 [SIG_COEF_CONTEXTS_EOB][NUM_BASE_LEVELS + 1];
1205 unsigned int newmv_mode[NEWMV_MODE_CONTEXTS][2];
1206 unsigned int zeromv_mode[GLOBALMV_MODE_CONTEXTS][2];
1207 unsigned int refmv_mode[REFMV_MODE_CONTEXTS][2];
1208 unsigned int drl_mode[DRL_MODE_CONTEXTS][2];
1209 unsigned int inter_compound_mode[INTER_MODE_CONTEXTS][INTER_COMPOUND_MODES];
1210 unsigned int wedge_idx[BLOCK_SIZES_ALL][16];
1211 unsigned int interintra[BLOCK_SIZE_GROUPS][2];
1212 unsigned int interintra_mode[BLOCK_SIZE_GROUPS][INTERINTRA_MODES];
1213 unsigned int wedge_interintra[BLOCK_SIZES_ALL][2];
1214 unsigned int compound_type[BLOCK_SIZES_ALL][MASKED_COMPOUND_TYPES];
1215 unsigned int motion_mode[BLOCK_SIZES_ALL][MOTION_MODES];
1216 unsigned int obmc[BLOCK_SIZES_ALL][2];
1217 unsigned int intra_inter[INTRA_INTER_CONTEXTS][2];
1218 unsigned int comp_inter[COMP_INTER_CONTEXTS][2];
1219 unsigned int comp_ref_type[COMP_REF_TYPE_CONTEXTS][2];
1220 unsigned int uni_comp_ref[UNI_COMP_REF_CONTEXTS][UNIDIR_COMP_REFS - 1][2];
1221 unsigned int single_ref[REF_CONTEXTS][SINGLE_REFS - 1][2];
1222 unsigned int comp_ref[REF_CONTEXTS][FWD_REFS - 1][2];
1223 unsigned int comp_bwdref[REF_CONTEXTS][BWD_REFS - 1][2];
1224 unsigned int intrabc[2];
1225
1226 unsigned int txfm_partition[TXFM_PARTITION_CONTEXTS][2];
1227 unsigned int intra_tx_size[MAX_TX_CATS][TX_SIZE_CONTEXTS][MAX_TX_DEPTH + 1];
1228 unsigned int skip_mode[SKIP_MODE_CONTEXTS][2];
1229 unsigned int skip_txfm[SKIP_CONTEXTS][2];
1230 unsigned int compound_index[COMP_INDEX_CONTEXTS][2];
1231 unsigned int comp_group_idx[COMP_GROUP_IDX_CONTEXTS][2];
1232 unsigned int delta_q[DELTA_Q_PROBS][2];
1233 unsigned int delta_lf_multi[FRAME_LF_COUNT][DELTA_LF_PROBS][2];
1234 unsigned int delta_lf[DELTA_LF_PROBS][2];
1235
1236 unsigned int inter_ext_tx[EXT_TX_SETS_INTER][EXT_TX_SIZES][TX_TYPES];
1237 unsigned int intra_ext_tx[EXT_TX_SETS_INTRA][EXT_TX_SIZES][INTRA_MODES]
1238 [TX_TYPES];
1239 unsigned int filter_intra_mode[FILTER_INTRA_MODES];
1240 unsigned int filter_intra[BLOCK_SIZES_ALL][2];
1241 unsigned int switchable_restore[RESTORE_SWITCHABLE_TYPES];
1242 unsigned int wiener_restore[2];
1243 unsigned int sgrproj_restore[2];
1244#endif // CONFIG_ENTROPY_STATS
1245
1246 unsigned int switchable_interp[SWITCHABLE_FILTER_CONTEXTS]
1247 [SWITCHABLE_FILTERS];
1248} FRAME_COUNTS;
1249
1250#define INTER_MODE_RD_DATA_OVERALL_SIZE 6400
1251
1252typedef struct {
1253 int ready;
1254 double a;
1255 double b;
1256 double dist_mean;
1257 double ld_mean;
1258 double sse_mean;
1259 double sse_sse_mean;
1260 double sse_ld_mean;
1261 int num;
1262 double dist_sum;
1263 double ld_sum;
1264 double sse_sum;
1265 double sse_sse_sum;
1266 double sse_ld_sum;
1267} InterModeRdModel;
1268
1269typedef struct {
1270 int idx;
1271 int64_t rd;
1272} RdIdxPair;
1273// TODO(angiebird): This is an estimated size. We still need to figure what is
1274// the maximum number of modes.
1275#define MAX_INTER_MODES 1024
1276// TODO(any): rename this struct to something else. There is already another
1277// struct called inter_mode_info, which makes this terribly confusing.
1285typedef struct inter_modes_info {
1290 int num;
1294 MB_MODE_INFO mbmi_arr[MAX_INTER_MODES];
1298 int mode_rate_arr[MAX_INTER_MODES];
1302 int64_t sse_arr[MAX_INTER_MODES];
1306 int64_t est_rd_arr[MAX_INTER_MODES];
1310 RdIdxPair rd_idx_pair_arr[MAX_INTER_MODES];
1314 RD_STATS rd_cost_arr[MAX_INTER_MODES];
1318 RD_STATS rd_cost_y_arr[MAX_INTER_MODES];
1322 RD_STATS rd_cost_uv_arr[MAX_INTER_MODES];
1324
1326typedef struct {
1327 // TODO(kyslov): consider changing to 64bit
1328
1329 // This struct is used for computing variance in choose_partitioning(), where
1330 // the max number of samples within a superblock is 32x32 (with 4x4 avg).
1331 // With 8bit bitdepth, uint32_t is enough for sum_square_error (2^8 * 2^8 * 32
1332 // * 32 = 2^26). For high bitdepth we need to consider changing this to 64 bit
1333 uint32_t sum_square_error;
1334 int32_t sum_error;
1335 int log2_count;
1336 int variance;
1337} VPartVar;
1338
1339typedef struct {
1340 VPartVar none;
1341 VPartVar horz[2];
1342 VPartVar vert[2];
1343} VPVariance;
1344
1345typedef struct {
1346 VPVariance part_variances;
1347 VPartVar split[4];
1348} VP4x4;
1349
1350typedef struct {
1351 VPVariance part_variances;
1352 VP4x4 split[4];
1353} VP8x8;
1354
1355typedef struct {
1356 VPVariance part_variances;
1357 VP8x8 split[4];
1358} VP16x16;
1359
1360typedef struct {
1361 VPVariance part_variances;
1362 VP16x16 split[4];
1363} VP32x32;
1364
1365typedef struct {
1366 VPVariance part_variances;
1367 VP32x32 split[4];
1368} VP64x64;
1369
1370typedef struct {
1371 VPVariance part_variances;
1372 VP64x64 *split;
1373} VP128x128;
1374
1376
1380typedef struct {
1389 int64_t thresholds[5];
1390
1397
1401typedef struct {
1402#if CONFIG_MULTITHREAD
1407 pthread_mutex_t *mutex_;
1408 pthread_cond_t *cond_;
1410#endif // CONFIG_MULTITHREAD
1434 int rows;
1444
1446
1447// TODO(jingning) All spatially adaptive variables should go to TileDataEnc.
1448typedef struct TileDataEnc {
1449 TileInfo tile_info;
1450 DECLARE_ALIGNED(16, FRAME_CONTEXT, tctx);
1451 FRAME_CONTEXT *row_ctx;
1452 uint64_t abs_sum_level;
1453 uint8_t allow_update_cdf;
1454 InterModeRdModel inter_mode_rd_models[BLOCK_SIZES_ALL];
1455 AV1EncRowMultiThreadSync row_mt_sync;
1456 MV firstpass_top_mv;
1457} TileDataEnc;
1458
1459typedef struct RD_COUNTS {
1460 int compound_ref_used_flag;
1461 int skip_mode_used_flag;
1462 int tx_type_used[TX_SIZES_ALL][TX_TYPES];
1463 int obmc_used[BLOCK_SIZES_ALL][2];
1464 int warped_used[2];
1465 int newmv_or_intra_blocks;
1466 uint64_t seg_tmp_pred_cost[2];
1467} RD_COUNTS;
1468
1469typedef struct ThreadData {
1470 MACROBLOCK mb;
1471 MvCosts *mv_costs_alloc;
1472 IntraBCMVCosts *dv_costs_alloc;
1473 RD_COUNTS rd_counts;
1474 FRAME_COUNTS *counts;
1475 PC_TREE_SHARED_BUFFERS shared_coeff_buf;
1476 SIMPLE_MOTION_DATA_TREE *sms_tree;
1477 SIMPLE_MOTION_DATA_TREE *sms_root;
1478 uint32_t *hash_value_buffer[2][2];
1479 OBMCBuffer obmc_buffer;
1480 PALETTE_BUFFER *palette_buffer;
1481 CompoundTypeRdBuffers comp_rd_buffer;
1482 CONV_BUF_TYPE *tmp_conv_dst;
1483 uint64_t abs_sum_level;
1484 uint8_t *tmp_pred_bufs[2];
1485 uint8_t *wiener_tmp_pred_buf;
1486 int intrabc_used;
1487 int deltaq_used;
1488 int coefficient_size;
1489 int max_mv_magnitude;
1490 int interp_filter_selected[SWITCHABLE];
1491 FRAME_CONTEXT *tctx;
1492 VP64x64 *vt64x64;
1493 int32_t num_64x64_blocks;
1494 PICK_MODE_CONTEXT *firstpass_ctx;
1495 TemporalFilterData tf_data;
1496 TplBuffers tpl_tmp_buffers;
1497 TplTxfmStats tpl_txfm_stats;
1498 GlobalMotionData gm_data;
1499 // Pointer to the array of structures to store gradient information of each
1500 // pixel in a superblock. The buffer constitutes of MAX_SB_SQUARE pixel level
1501 // structures for each of the plane types (PLANE_TYPE_Y and PLANE_TYPE_UV).
1502 PixelLevelGradientInfo *pixel_gradient_info;
1503 // Pointer to the array of structures to store source variance information of
1504 // each 4x4 sub-block in a superblock. Block4x4VarInfo structure is used to
1505 // store source variance and log of source variance of each 4x4 sub-block
1506 // for subsequent retrieval.
1507 Block4x4VarInfo *src_var_info_of_4x4_sub_blocks;
1508 // Pointer to pc tree root.
1509 PC_TREE *pc_root;
1510} ThreadData;
1511
1512struct EncWorkerData;
1513
1515
1519typedef struct {
1542
1546 int thread_id_to_tile_id[MAX_NUM_THREADS];
1547
1553
1559
1565
1572
1579
1580#if CONFIG_MULTITHREAD
1584 pthread_mutex_t *mutex_;
1588 pthread_cond_t *cond_;
1589#endif
1590
1598 void (*sync_read_ptr)(AV1EncRowMultiThreadSync *const, int, int);
1602 void (*sync_write_ptr)(AV1EncRowMultiThreadSync *const, int, int, int);
1605
1609typedef struct {
1610#if CONFIG_MULTITHREAD
1614 pthread_mutex_t *mutex_;
1618 pthread_cond_t *cond_;
1619#endif
1620
1632 void (*intra_sync_write_ptr)(AV1EncRowMultiThreadSync *const, int, int, int);
1635
1639#define NUM_RECODES_PER_FRAME 10
1640
1644#define MAX_PARALLEL_FRAMES 4
1645
1650typedef struct RestoreStateBuffers {
1654 uint16_t *cdef_srcbuf;
1655
1659 uint16_t *cdef_colbuf[MAX_MB_PLANE];
1660
1664 int32_t *rst_tmpbuf;
1665
1669 RestorationLineBuffers *rlbs;
1671
1692
1698typedef struct {
1703 RestUnitSearchInfo *rusi[MAX_MB_PLANE];
1704
1708 int16_t *dgd_avg;
1710
1719
1723 int num_mod_workers[NUM_MT_MODULES];
1724
1728 AVxWorker *workers;
1729
1734 struct EncWorkerData *tile_thr_data;
1735
1739 AV1CdefWorkerData *cdef_worker;
1740
1746
1751
1757
1761typedef struct MultiThreadInfo {
1766
1770 int num_mod_workers[NUM_MT_MODULES];
1771
1775 AVxWorker *workers;
1776
1781 struct EncWorkerData *tile_thr_data;
1782
1788
1793
1798
1804
1808 AV1TplRowMultiThreadInfo tpl_row_mt;
1809
1813 AV1LfSync lf_row_sync;
1814
1818 AV1LrSync lr_row_sync;
1819
1823 AV1EncPackBSSync pack_bs_sync;
1824
1828 AV1GlobalMotionSync gm_sync;
1829
1833 AV1TemporalFilterSync tf_sync;
1834
1838 AV1CdefSync cdef_sync;
1839
1843 AV1CdefWorkerData *cdef_worker;
1844
1849
1856
1858
1859typedef struct ActiveMap {
1860 int enabled;
1861 int update;
1862 unsigned char *map;
1863} ActiveMap;
1864
1866
1870typedef struct {
1875 double cs_rate_array[32];
1885
1887
1888#if CONFIG_INTERNAL_STATS
1889// types of stats
1890enum {
1891 STAT_Y,
1892 STAT_U,
1893 STAT_V,
1894 STAT_ALL,
1895 NUM_STAT_TYPES // This should always be the last member of the enum
1896} UENUM1BYTE(StatType);
1897
1898typedef struct IMAGE_STAT {
1899 double stat[NUM_STAT_TYPES];
1900 double worst;
1901} ImageStat;
1902#endif // CONFIG_INTERNAL_STATS
1903
1904typedef struct {
1905 int ref_count;
1906 YV12_BUFFER_CONFIG buf;
1907} EncRefCntBuffer;
1908
1910
1931
1933
1934#if CONFIG_COLLECT_PARTITION_STATS
1935typedef struct FramePartitionTimingStats {
1936 int partition_decisions[6][EXT_PARTITION_TYPES];
1937 int partition_attempts[6][EXT_PARTITION_TYPES];
1938 int64_t partition_times[6][EXT_PARTITION_TYPES];
1939
1940 int partition_redo;
1941} FramePartitionTimingStats;
1942#endif // CONFIG_COLLECT_PARTITION_STATS
1943
1944#if CONFIG_COLLECT_COMPONENT_TIMING
1945#include "aom_ports/aom_timer.h"
1946// Adjust the following to add new components.
1947enum {
1948 av1_encode_strategy_time,
1949 av1_get_one_pass_rt_params_time,
1950 av1_get_second_pass_params_time,
1951 denoise_and_encode_time,
1952 apply_filtering_time,
1953 av1_tpl_setup_stats_time,
1954 encode_frame_to_data_rate_time,
1955 encode_with_or_without_recode_time,
1956 loop_filter_time,
1957 cdef_time,
1958 loop_restoration_time,
1959 av1_pack_bitstream_final_time,
1960 av1_encode_frame_time,
1961 av1_compute_global_motion_time,
1962 av1_setup_motion_field_time,
1963 encode_sb_row_time,
1964
1965 rd_pick_partition_time,
1966 rd_use_partition_time,
1967 choose_var_based_partitioning_time,
1968 av1_prune_partitions_time,
1969 none_partition_search_time,
1970 split_partition_search_time,
1971 rectangular_partition_search_time,
1972 ab_partitions_search_time,
1973 rd_pick_4partition_time,
1974 encode_sb_time,
1975
1976 rd_pick_sb_modes_time,
1977 av1_rd_pick_intra_mode_sb_time,
1978 av1_rd_pick_inter_mode_sb_time,
1979 set_params_rd_pick_inter_mode_time,
1980 skip_inter_mode_time,
1981 handle_inter_mode_time,
1982 evaluate_motion_mode_for_winner_candidates_time,
1983 do_tx_search_time,
1984 handle_intra_mode_time,
1985 refine_winner_mode_tx_time,
1986 av1_search_palette_mode_time,
1987 handle_newmv_time,
1988 compound_type_rd_time,
1989 interpolation_filter_search_time,
1990 motion_mode_rd_time,
1991
1992 nonrd_use_partition_time,
1993 pick_sb_modes_nonrd_time,
1994 hybrid_intra_mode_search_time,
1995 nonrd_pick_inter_mode_sb_time,
1996 encode_b_nonrd_time,
1997
1998 kTimingComponents,
1999} UENUM1BYTE(TIMING_COMPONENT);
2000
2001static inline char const *get_component_name(int index) {
2002 switch (index) {
2003 case av1_encode_strategy_time: return "av1_encode_strategy_time";
2004 case av1_get_one_pass_rt_params_time:
2005 return "av1_get_one_pass_rt_params_time";
2006 case av1_get_second_pass_params_time:
2007 return "av1_get_second_pass_params_time";
2008 case denoise_and_encode_time: return "denoise_and_encode_time";
2009 case apply_filtering_time: return "apply_filtering_time";
2010 case av1_tpl_setup_stats_time: return "av1_tpl_setup_stats_time";
2011 case encode_frame_to_data_rate_time:
2012 return "encode_frame_to_data_rate_time";
2013 case encode_with_or_without_recode_time:
2014 return "encode_with_or_without_recode_time";
2015 case loop_filter_time: return "loop_filter_time";
2016 case cdef_time: return "cdef_time";
2017 case loop_restoration_time: return "loop_restoration_time";
2018 case av1_pack_bitstream_final_time: return "av1_pack_bitstream_final_time";
2019 case av1_encode_frame_time: return "av1_encode_frame_time";
2020 case av1_compute_global_motion_time:
2021 return "av1_compute_global_motion_time";
2022 case av1_setup_motion_field_time: return "av1_setup_motion_field_time";
2023 case encode_sb_row_time: return "encode_sb_row_time";
2024
2025 case rd_pick_partition_time: return "rd_pick_partition_time";
2026 case rd_use_partition_time: return "rd_use_partition_time";
2027 case choose_var_based_partitioning_time:
2028 return "choose_var_based_partitioning_time";
2029 case av1_prune_partitions_time: return "av1_prune_partitions_time";
2030 case none_partition_search_time: return "none_partition_search_time";
2031 case split_partition_search_time: return "split_partition_search_time";
2032 case rectangular_partition_search_time:
2033 return "rectangular_partition_search_time";
2034 case ab_partitions_search_time: return "ab_partitions_search_time";
2035 case rd_pick_4partition_time: return "rd_pick_4partition_time";
2036 case encode_sb_time: return "encode_sb_time";
2037
2038 case rd_pick_sb_modes_time: return "rd_pick_sb_modes_time";
2039 case av1_rd_pick_intra_mode_sb_time:
2040 return "av1_rd_pick_intra_mode_sb_time";
2041 case av1_rd_pick_inter_mode_sb_time:
2042 return "av1_rd_pick_inter_mode_sb_time";
2043 case set_params_rd_pick_inter_mode_time:
2044 return "set_params_rd_pick_inter_mode_time";
2045 case skip_inter_mode_time: return "skip_inter_mode_time";
2046 case handle_inter_mode_time: return "handle_inter_mode_time";
2047 case evaluate_motion_mode_for_winner_candidates_time:
2048 return "evaluate_motion_mode_for_winner_candidates_time";
2049 case do_tx_search_time: return "do_tx_search_time";
2050 case handle_intra_mode_time: return "handle_intra_mode_time";
2051 case refine_winner_mode_tx_time: return "refine_winner_mode_tx_time";
2052 case av1_search_palette_mode_time: return "av1_search_palette_mode_time";
2053 case handle_newmv_time: return "handle_newmv_time";
2054 case compound_type_rd_time: return "compound_type_rd_time";
2055 case interpolation_filter_search_time:
2056 return "interpolation_filter_search_time";
2057 case motion_mode_rd_time: return "motion_mode_rd_time";
2058
2059 case nonrd_use_partition_time: return "nonrd_use_partition_time";
2060 case pick_sb_modes_nonrd_time: return "pick_sb_modes_nonrd_time";
2061 case hybrid_intra_mode_search_time: return "hybrid_intra_mode_search_time";
2062 case nonrd_pick_inter_mode_sb_time: return "nonrd_pick_inter_mode_sb_time";
2063 case encode_b_nonrd_time: return "encode_b_nonrd_time";
2064
2065 default: assert(0);
2066 }
2067 return "error";
2068}
2069#endif
2070
2071// The maximum number of internal ARFs except ALTREF_FRAME
2072#define MAX_INTERNAL_ARFS (REF_FRAMES - BWDREF_FRAME - 1)
2073
2075
2079typedef struct {
2084
2090 YV12_BUFFER_CONFIG *ref_buf[REF_FRAMES];
2091
2097 int num_ref_frames[MAX_DIRECTIONS];
2098
2105 FrameDistPair reference_frames[MAX_DIRECTIONS][REF_FRAMES - 1];
2106
2115
2130
2134typedef struct {
2154 fractional_mv_step_fp *find_fractional_mv_step;
2161 search_site_config search_site_cfg[SS_CFG_TOTAL][NUM_DISTINCT_SEARCH_METHODS];
2163
2177
2185typedef struct {
2186 int width;
2189
2193typedef struct {
2197 int ref_relative_dist[INTER_REFS_PER_FRAME];
2207
2223typedef struct {
2231 unsigned int coeff_opt_thresholds[MODE_EVAL_TYPES][2];
2232
2237 TX_SIZE_SEARCH_METHOD tx_size_search_methods[MODE_EVAL_TYPES];
2238
2245 unsigned int use_transform_domain_distortion[MODE_EVAL_TYPES];
2246
2252 unsigned int tx_domain_dist_threshold[MODE_EVAL_TYPES];
2253
2259 unsigned int skip_txfm_level[MODE_EVAL_TYPES];
2260
2266 unsigned int predict_dc_level[MODE_EVAL_TYPES];
2268
2287
2334
2336
2337typedef struct {
2338 // Some misc info
2339 int high_prec;
2340 int q;
2341 int order;
2342
2343 // MV counters
2344 int inter_count;
2345 int intra_count;
2346 int default_mvs;
2347 int mv_joint_count[4];
2348 int last_bit_zero;
2349 int last_bit_nonzero;
2350
2351 // Keep track of the rates
2352 int total_mv_rate;
2353 int hp_total_mv_rate;
2354 int lp_total_mv_rate;
2355
2356 // Texture info
2357 int horz_text;
2358 int vert_text;
2359 int diag_text;
2360
2361 // Whether the current struct contains valid data
2362 int valid;
2363} MV_STATS;
2364
2365typedef struct WeberStats {
2366 int64_t mb_wiener_variance;
2367 int64_t src_variance;
2368 int64_t rec_variance;
2369 int16_t src_pix_max;
2370 int16_t rec_pix_max;
2371 int64_t distortion;
2372 int64_t satd;
2373 double max_scale;
2374} WeberStats;
2375
2376typedef struct {
2377 struct loopfilter lf;
2378 CdefInfo cdef_info;
2379 YV12_BUFFER_CONFIG copy_buffer;
2380 RATE_CONTROL rc;
2381 MV_STATS mv_stats;
2382} CODING_CONTEXT;
2383
2384typedef struct {
2385 int frame_width;
2386 int frame_height;
2387 int mi_rows;
2388 int mi_cols;
2389 int mb_rows;
2390 int mb_cols;
2391 int num_mbs;
2392 aom_bit_depth_t bit_depth;
2393 int subsampling_x;
2394 int subsampling_y;
2395} FRAME_INFO;
2396
2400typedef struct {
2401 int show_frame_count;
2402} FRAME_INDEX_SET;
2403
2405
2409typedef struct {
2415 uint8_t *map;
2423
2427typedef struct {
2440} TimeStamps;
2441
2446typedef struct {
2450 tran_low_t *tcoeff;
2454 uint16_t *eobs;
2458 uint8_t *entropy_ctx;
2460
2461#if !CONFIG_REALTIME_ONLY
2463// DUCKY_ENCODE_FRAME_MODE is c version of EncodeFrameMode
2464enum {
2465 DUCKY_ENCODE_FRAME_MODE_NONE, // Let native AV1 determine q index and rdmult
2466 DUCKY_ENCODE_FRAME_MODE_QINDEX, // DuckyEncode determines q index and AV1
2467 // determines rdmult
2468 DUCKY_ENCODE_FRAME_MODE_QINDEX_RDMULT, // DuckyEncode determines q index and
2469 // rdmult
2470} UENUM1BYTE(DUCKY_ENCODE_FRAME_MODE);
2471
2472enum {
2473 DUCKY_ENCODE_GOP_MODE_NONE, // native AV1 decides GOP
2474 DUCKY_ENCODE_GOP_MODE_RCL, // rate control lib decides GOP
2475} UENUM1BYTE(DUCKY_ENCODE_GOP_MODE);
2476
2477typedef struct DuckyEncodeFrameInfo {
2478 DUCKY_ENCODE_FRAME_MODE qp_mode;
2479 DUCKY_ENCODE_GOP_MODE gop_mode;
2480 int q_index;
2481 int rdmult;
2482 // These two arrays are equivalent to std::vector<SuperblockEncodeParameters>
2483 int *superblock_encode_qindex;
2484 int *superblock_encode_rdmult;
2485 int delta_q_enabled;
2486} DuckyEncodeFrameInfo;
2487
2488typedef struct DuckyEncodeFrameResult {
2489 int global_order_idx;
2490 int q_index;
2491 int rdmult;
2492 int rate;
2493 int64_t dist;
2494 double psnr;
2495} DuckyEncodeFrameResult;
2496
2497typedef struct DuckyEncodeInfo {
2498 DuckyEncodeFrameInfo frame_info;
2499 DuckyEncodeFrameResult frame_result;
2500} DuckyEncodeInfo;
2502#endif
2503
2505typedef struct RTC_REF {
2510 int reference[INTER_REFS_PER_FRAME];
2511 int ref_idx[INTER_REFS_PER_FRAME];
2512 int refresh[REF_FRAMES];
2513 int set_ref_frame_config;
2514 int non_reference_frame;
2515 int ref_frame_comp[3];
2516 int gld_idx_1layer;
2520 unsigned int buffer_time_index[REF_FRAMES];
2524 unsigned char buffer_spatial_layer[REF_FRAMES];
2528 bool reference_was_previous_frame;
2533 bool bias_recovery_frame;
2534} RTC_REF;
2536
2540typedef struct AV1_COMP_DATA {
2544 unsigned char *cx_data;
2545
2550
2555
2559 unsigned int lib_flags;
2560
2565
2570
2575
2579 const aom_rational64_t *timestamp_ratio;
2580
2586
2590typedef struct AV1_PRIMARY {
2595
2601#if CONFIG_FPMT_TEST
2607 FPMT_TEST_ENC_CFG fpmt_unit_test_cfg;
2608
2612 FrameProbInfo temp_frame_probs;
2613
2619 FrameProbInfo temp_frame_probs_simulation;
2620
2625 int temp_valid_gm_model_found[FRAME_UPDATE_TYPES];
2626#endif // CONFIG_FPMT_TEST
2632 RefCntBuffer *ref_frame_map_copy[REF_FRAMES];
2633
2638
2643
2648
2653
2658
2663
2668 struct AV1_COMP *cpi;
2669
2674
2678 struct lookahead_ctx *lookahead;
2679
2690
2695 struct aom_codec_pkt_list *output_pkt_list;
2696
2701
2706
2711
2715 GF_STATE gf_state;
2716
2721
2725 AV1LevelParams level_params;
2726
2731
2736
2741
2746
2755 SequenceHeader seq_params;
2756
2761
2766
2771
2776
2780 struct aom_internal_error_info error;
2781
2787 aom_variance_fn_ptr_t fn_ptr[BLOCK_SIZES_ALL];
2788
2794
2799
2803 MV_STATS mv_stats;
2804
2805#if CONFIG_INTERNAL_STATS
2807 uint64_t total_time_receive_data;
2808 uint64_t total_time_compress_data;
2809
2810 unsigned int total_mode_chosen_counts[MAX_MODES];
2811
2812 int count[2];
2813 uint64_t total_sq_error[2];
2814 uint64_t total_samples[2];
2815 ImageStat psnr[2];
2816
2817 double total_blockiness;
2818 double worst_blockiness;
2819
2820 uint64_t total_bytes;
2821 double summed_quality;
2822 double summed_weights;
2823 double summed_quality_hbd;
2824 double summed_weights_hbd;
2825 unsigned int total_recode_hits;
2826 double worst_ssim;
2827 double worst_ssim_hbd;
2828
2829 ImageStat fastssim;
2830 ImageStat psnrhvs;
2831
2832 int b_calculate_blockiness;
2833 int b_calculate_consistency;
2834
2835 double total_inconsistency;
2836 double worst_consistency;
2837 Ssimv *ssim_vars;
2838 Metrics metrics;
2840#endif
2841
2842#if CONFIG_ENTROPY_STATS
2846 FRAME_COUNTS aggregate_fc;
2847#endif // CONFIG_ENTROPY_STATS
2848
2855 int fb_of_context_type[REF_FRAMES];
2856
2861
2866
2873 int valid_gm_model_found[FRAME_UPDATE_TYPES];
2874
2878 RTC_REF rtc_ref;
2879
2886
2890typedef struct AV1_COMP {
2895
2900 EncQuantDequantParams enc_quant_dequant_params;
2901
2905 ThreadData td;
2906
2910 FRAME_COUNTS counts;
2911
2916
2923
2929
2933 AV1_COMMON common;
2934
2939
2944 TRELLIS_OPT_TYPE optimize_seg_arr[MAX_SEGMENTS];
2945
2951 YV12_BUFFER_CONFIG *source;
2952
2960 YV12_BUFFER_CONFIG *last_source;
2961
2966 YV12_BUFFER_CONFIG *unscaled_source;
2967
2971 YV12_BUFFER_CONFIG scaled_source;
2972
2976 YV12_BUFFER_CONFIG *unscaled_last_source;
2977
2981 YV12_BUFFER_CONFIG scaled_last_source;
2982
2987 YV12_BUFFER_CONFIG *unfiltered_source;
2988
2993 YV12_BUFFER_CONFIG orig_source;
2994
2999
3009
3014
3018 CdefSearchCtx *cdef_search_ctx;
3019
3024
3029 RefCntBuffer *scaled_ref_buf[INTER_REFS_PER_FRAME];
3030
3034 RefCntBuffer *last_show_frame_buf;
3035
3040
3045
3050
3055 YV12_BUFFER_CONFIG last_frame_uf;
3056
3061 YV12_BUFFER_CONFIG trial_frame_rst;
3062
3067
3071 RD_OPT rd;
3072
3077 CODING_CONTEXT coding_context;
3078
3083
3088
3093
3098
3103
3108
3113
3118
3123
3129
3134
3143 ActiveMap active_map;
3144
3148 unsigned char gf_frame_index;
3149
3150#if CONFIG_INTERNAL_STATS
3152 uint64_t time_compress_data;
3153
3154 unsigned int mode_chosen_counts[MAX_MODES];
3155 int bytes;
3156 unsigned int frame_recode_hits;
3158#endif
3159
3160#if CONFIG_SPEED_STATS
3164 unsigned int tx_search_count;
3165#endif // CONFIG_SPEED_STATS
3166
3172
3176 FRAME_INFO frame_info;
3177
3181 FRAME_INDEX_SET frame_index_set;
3182
3189
3196
3204
3210
3216
3222
3227
3232 TileDataEnc *tile_data;
3237
3241 TokenInfo token_info;
3242
3247
3252
3257
3262
3267
3272
3277
3282
3283#if CONFIG_FPMT_TEST
3288 double temp_framerate;
3289#endif
3296
3301
3306
3313
3318
3323
3327 AV1LrStruct lr_ctxt;
3328
3333
3337 aom_film_grain_table_t *film_grain_table;
3338
3339#if CONFIG_DENOISE
3344 struct aom_denoise_and_model_t *denoise_and_model;
3345#endif
3346
3351
3360
3368
3369#if CONFIG_COLLECT_PARTITION_STATS
3373 FramePartitionTimingStats partition_stats;
3374#endif // CONFIG_COLLECT_PARTITION_STATS
3375
3376#if CONFIG_COLLECT_COMPONENT_TIMING
3380 uint64_t component_time[kTimingComponents];
3385 struct aom_usec_timer component_timer[kTimingComponents];
3389 uint64_t frame_component_time[kTimingComponents];
3390#endif
3391
3396
3401
3406
3413
3414#if CONFIG_TUNE_VMAF
3418 TuneVMAFInfo vmaf_info;
3419#endif
3420
3421#if CONFIG_TUNE_BUTTERAUGLI
3425 TuneButteraugliInfo butteraugli_info;
3426#endif
3427
3432
3436 COMPRESSOR_STAGE compressor_stage;
3437
3443
3448
3455
3459 FirstPassData firstpass_data;
3460
3464 NOISE_ESTIMATE noise_estimate;
3465
3466#if CONFIG_AV1_TEMPORAL_DENOISING
3470 AV1_DENOISER denoiser;
3471#endif
3472
3478
3483
3487 BLOCK_SIZE fp_block_size;
3488
3494
3499
3504 ExtPartController ext_part_controller;
3505
3510 MV_STATS mv_stats;
3515
3521
3528#if CONFIG_FPMT_TEST
3534
3535 int wanted_fb;
3536#endif // CONFIG_FPMT_TEST
3537
3544
3545#if CONFIG_RD_COMMAND
3549 RD_COMMAND rd_command;
3550#endif // CONFIG_RD_COMMAND
3551
3555 WeberStats *mb_weber_stats;
3556
3562
3568
3573
3577 BLOCK_SIZE weber_bsize;
3578
3583
3588
3593
3594#if CONFIG_BITRATE_ACCURACY
3598 VBR_RATECTRL_INFO vbr_rc_info;
3599#endif
3600
3601#if CONFIG_RATECTRL_LOG
3605 RATECTRL_LOG rc_log;
3606#endif // CONFIG_RATECTRL_LOG
3607
3612
3613#if CONFIG_THREE_PASS
3617 THIRD_PASS_DEC_CTX *third_pass_ctx;
3618#endif
3619
3624
3629
3635 uint64_t rec_sse;
3636
3642
3643#if !CONFIG_REALTIME_ONLY
3647 DuckyEncodeInfo ducky_encode_info;
3648#endif // CONFIG_REALTIME_ONLY
3649 //
3654
3658 unsigned int zeromv_skip_thresh_exit_part[BLOCK_SIZES_ALL];
3659
3665
3666#if CONFIG_SALIENCY_MAP
3670 uint8_t *saliency_map;
3671
3675 double *sm_scaling_factor;
3676#endif
3677
3683
3689
3695
3699typedef struct EncodeFrameInput {
3701 YV12_BUFFER_CONFIG *source;
3702 YV12_BUFFER_CONFIG *last_source;
3703 int64_t ts_duration;
3706
3711typedef struct EncodeFrameParams {
3719 FRAME_TYPE frame_type;
3720
3722 int primary_ref_frame;
3723 int order_offset;
3724
3730
3732 int refresh_frame_flags;
3733
3734 int show_existing_frame;
3735 int existing_fb_idx_to_show;
3736
3742
3746 int remapped_ref_idx[REF_FRAMES];
3747
3753
3759
3761
3762void av1_initialize_enc(unsigned int usage, enum aom_rc_mode end_usage);
3763
3764struct AV1_COMP *av1_create_compressor(AV1_PRIMARY *ppi,
3765 const AV1EncoderConfig *oxcf,
3766 BufferPool *const pool,
3767 COMPRESSOR_STAGE stage,
3768 int lap_lag_in_frames);
3769
3770struct AV1_PRIMARY *av1_create_primary_compressor(
3771 struct aom_codec_pkt_list *pkt_list_head, int num_lap_buffers,
3772 const AV1EncoderConfig *oxcf);
3773
3774void av1_remove_compressor(AV1_COMP *cpi);
3775
3776void av1_remove_primary_compressor(AV1_PRIMARY *ppi);
3777
3778#if CONFIG_ENTROPY_STATS
3779void print_entropy_stats(AV1_PRIMARY *const ppi);
3780#endif
3781#if CONFIG_INTERNAL_STATS
3782void print_internal_stats(AV1_PRIMARY *ppi);
3783#endif
3784
3785void av1_change_config_seq(AV1_PRIMARY *ppi, const AV1EncoderConfig *oxcf,
3786 bool *sb_size_changed);
3787
3788void av1_change_config(AV1_COMP *cpi, const AV1EncoderConfig *oxcf,
3789 bool sb_size_changed);
3790
3791aom_codec_err_t av1_check_initial_width(AV1_COMP *cpi, int use_highbitdepth,
3792 int subsampling_x, int subsampling_y);
3793
3794void av1_post_encode_updates(AV1_COMP *const cpi,
3795 const AV1_COMP_DATA *const cpi_data);
3796
3797void av1_release_scaled_references_fpmt(AV1_COMP *cpi);
3798
3799void av1_decrement_ref_counts_fpmt(BufferPool *buffer_pool,
3800 int ref_buffers_used_map);
3801
3802void av1_init_sc_decisions(AV1_PRIMARY *const ppi);
3803
3804AV1_COMP *av1_get_parallel_frame_enc_data(AV1_PRIMARY *const ppi,
3805 AV1_COMP_DATA *const first_cpi_data);
3806
3807int av1_init_parallel_frame_context(const AV1_COMP_DATA *const first_cpi_data,
3808 AV1_PRIMARY *const ppi,
3809 int *ref_buffers_used_map);
3810
3812
3830 const YV12_BUFFER_CONFIG *sd, int64_t time_stamp,
3831 int64_t end_time_stamp);
3832
3854int av1_get_compressed_data(AV1_COMP *cpi, AV1_COMP_DATA *const cpi_data);
3855
3862int av1_encode(AV1_COMP *const cpi, uint8_t *const dest, size_t dest_size,
3863 const EncodeFrameInput *const frame_input,
3864 const EncodeFrameParams *const frame_params,
3865 size_t *const frame_size);
3866
3868int av1_get_preview_raw_frame(AV1_COMP *cpi, YV12_BUFFER_CONFIG *dest);
3869
3870int av1_get_last_show_frame(AV1_COMP *cpi, YV12_BUFFER_CONFIG *frame);
3871
3872aom_codec_err_t av1_copy_new_frame_enc(AV1_COMMON *cm,
3873 YV12_BUFFER_CONFIG *new_frame,
3874 YV12_BUFFER_CONFIG *sd);
3875
3876int av1_use_as_reference(int *ext_ref_frame_flags, int ref_frame_flags);
3877
3878int av1_copy_reference_enc(AV1_COMP *cpi, int idx, YV12_BUFFER_CONFIG *sd);
3879
3880int av1_set_reference_enc(AV1_COMP *cpi, int idx, YV12_BUFFER_CONFIG *sd);
3881
3882void av1_set_frame_size(AV1_COMP *cpi, int width, int height);
3883
3884void av1_set_mv_search_params(AV1_COMP *cpi);
3885
3886int av1_set_roi_map(AV1_COMP *cpi, unsigned char *map, unsigned int rows,
3887 unsigned int cols, int delta_q[8], int delta_lf[8],
3888 int skip[8], int ref_frame[8]);
3889
3890int av1_set_active_map(AV1_COMP *cpi, unsigned char *map, int rows, int cols);
3891
3892int av1_get_active_map(AV1_COMP *cpi, unsigned char *map, int rows, int cols);
3893
3894int av1_set_internal_size(AV1EncoderConfig *const oxcf,
3895 ResizePendingParams *resize_pending_params,
3896 AOM_SCALING_MODE horiz_mode,
3897 AOM_SCALING_MODE vert_mode);
3898
3899int av1_get_quantizer(struct AV1_COMP *cpi);
3900
3901// This function assumes that the input buffer contains valid OBUs. It should
3902// not be called on untrusted input.
3903int av1_convert_sect5obus_to_annexb(uint8_t *buffer, size_t buffer_size,
3904 size_t *input_size);
3905
3906void av1_alloc_mb_wiener_var_pred_buf(AV1_COMMON *cm, ThreadData *td);
3907
3908void av1_dealloc_mb_wiener_var_pred_buf(ThreadData *td);
3909
3910uint8_t av1_find_dominant_value(const uint8_t *src, int stride, int rows,
3911 int cols);
3912
3913void av1_dilate_block(const uint8_t *src, int src_stride, uint8_t *dilated,
3914 int dilated_stride, int rows, int cols);
3915
3916// Set screen content options.
3917// This function estimates whether to use screen content tools, by counting
3918// the portion of blocks that have few luma colors.
3919// Modifies:
3920// cpi->commom.features.allow_screen_content_tools
3921// cpi->common.features.allow_intrabc
3922// cpi->use_screen_content_tools
3923// cpi->is_screen_content_type
3924// However, the estimation is not accurate and may misclassify videos.
3925// A slower but more accurate approach that determines whether to use screen
3926// content tools is employed later. See av1_determine_sc_tools_with_encoding().
3927void av1_set_screen_content_options(struct AV1_COMP *cpi,
3928 FeatureFlags *features);
3929
3930void av1_update_frame_size(AV1_COMP *cpi);
3931
3932void av1_set_svc_seq_params(AV1_PRIMARY *const ppi);
3933
3934typedef struct {
3935 int pyr_level;
3936 int disp_order;
3937} RefFrameMapPair;
3938
3939static inline void init_ref_map_pair(
3940 AV1_COMP *cpi, RefFrameMapPair ref_frame_map_pairs[REF_FRAMES]) {
3941 if (cpi->ppi->gf_group.update_type[cpi->gf_frame_index] == KF_UPDATE) {
3942 memset(ref_frame_map_pairs, -1, sizeof(*ref_frame_map_pairs) * REF_FRAMES);
3943 return;
3944 }
3945 memset(ref_frame_map_pairs, 0, sizeof(*ref_frame_map_pairs) * REF_FRAMES);
3946 for (int map_idx = 0; map_idx < REF_FRAMES; map_idx++) {
3947 // Get reference frame buffer.
3948 const RefCntBuffer *const buf = cpi->common.ref_frame_map[map_idx];
3949 if (ref_frame_map_pairs[map_idx].disp_order == -1) continue;
3950 if (buf == NULL) {
3951 ref_frame_map_pairs[map_idx].disp_order = -1;
3952 ref_frame_map_pairs[map_idx].pyr_level = -1;
3953 continue;
3954 } else if (buf->ref_count > 1) {
3955 // Once the keyframe is coded, the slots in ref_frame_map will all
3956 // point to the same frame. In that case, all subsequent pointers
3957 // matching the current are considered "free" slots. This will find
3958 // the next occurrence of the current pointer if ref_count indicates
3959 // there are multiple instances of it and mark it as free.
3960 for (int idx2 = map_idx + 1; idx2 < REF_FRAMES; ++idx2) {
3961 const RefCntBuffer *const buf2 = cpi->common.ref_frame_map[idx2];
3962 if (buf2 == buf) {
3963 ref_frame_map_pairs[idx2].disp_order = -1;
3964 ref_frame_map_pairs[idx2].pyr_level = -1;
3965 }
3966 }
3967 }
3968 ref_frame_map_pairs[map_idx].disp_order = (int)buf->display_order_hint;
3969 ref_frame_map_pairs[map_idx].pyr_level = buf->pyramid_level;
3970 }
3971}
3972
3973#if CONFIG_FPMT_TEST
3974static inline void calc_frame_data_update_flag(
3975 GF_GROUP *const gf_group, int gf_frame_index,
3976 bool *const do_frame_data_update) {
3977 *do_frame_data_update = true;
3978 // Set the flag to false for all frames in a given parallel encode set except
3979 // the last frame in the set with frame_parallel_level = 2.
3980 if (gf_group->frame_parallel_level[gf_frame_index] == 1) {
3981 *do_frame_data_update = false;
3982 } else if (gf_group->frame_parallel_level[gf_frame_index] == 2) {
3983 // Check if this is the last frame in the set with frame_parallel_level = 2.
3984 for (int i = gf_frame_index + 1; i < gf_group->size; i++) {
3985 if ((gf_group->frame_parallel_level[i] == 0 &&
3986 (gf_group->update_type[i] == ARF_UPDATE ||
3987 gf_group->update_type[i] == INTNL_ARF_UPDATE)) ||
3988 gf_group->frame_parallel_level[i] == 1) {
3989 break;
3990 } else if (gf_group->frame_parallel_level[i] == 2) {
3991 *do_frame_data_update = false;
3992 break;
3993 }
3994 }
3995 }
3996}
3997#endif
3998
3999// av1 uses 10,000,000 ticks/second as time stamp
4000#define TICKS_PER_SEC 10000000LL
4001
4002static inline int64_t timebase_units_to_ticks(
4003 const aom_rational64_t *timestamp_ratio, int64_t n) {
4004 return n * timestamp_ratio->num / timestamp_ratio->den;
4005}
4006
4007static inline int64_t ticks_to_timebase_units(
4008 const aom_rational64_t *timestamp_ratio, int64_t n) {
4009 int64_t round = timestamp_ratio->num / 2;
4010 if (round > 0) --round;
4011 return (n * timestamp_ratio->den + round) / timestamp_ratio->num;
4012}
4013
4014static inline int frame_is_kf_gf_arf(const AV1_COMP *cpi) {
4015 const GF_GROUP *const gf_group = &cpi->ppi->gf_group;
4016 const FRAME_UPDATE_TYPE update_type =
4017 gf_group->update_type[cpi->gf_frame_index];
4018
4019 return frame_is_intra_only(&cpi->common) || update_type == ARF_UPDATE ||
4020 update_type == GF_UPDATE;
4021}
4022
4023// TODO(huisu@google.com, youzhou@microsoft.com): enable hash-me for HBD.
4024static inline int av1_use_hash_me(const AV1_COMP *const cpi) {
4027 frame_is_intra_only(&cpi->common));
4028}
4029
4030static inline const YV12_BUFFER_CONFIG *get_ref_frame_yv12_buf(
4031 const AV1_COMMON *const cm, MV_REFERENCE_FRAME ref_frame) {
4032 const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame);
4033 return buf != NULL ? &buf->buf : NULL;
4034}
4035
4036static inline void alloc_frame_mvs(AV1_COMMON *const cm, RefCntBuffer *buf) {
4037 assert(buf != NULL);
4038 ensure_mv_buffer(buf, cm);
4039 buf->width = cm->width;
4040 buf->height = cm->height;
4041}
4042
4043// Get the allocated token size for a tile. It does the same calculation as in
4044// the frame token allocation.
4045static inline unsigned int allocated_tokens(const TileInfo *tile,
4046 int sb_size_log2, int num_planes) {
4047 int tile_mb_rows =
4048 ROUND_POWER_OF_TWO(tile->mi_row_end - tile->mi_row_start, 2);
4049 int tile_mb_cols =
4050 ROUND_POWER_OF_TWO(tile->mi_col_end - tile->mi_col_start, 2);
4051
4052 return get_token_alloc(tile_mb_rows, tile_mb_cols, sb_size_log2, num_planes);
4053}
4054
4055static inline void get_start_tok(AV1_COMP *cpi, int tile_row, int tile_col,
4056 int mi_row, TokenExtra **tok, int sb_size_log2,
4057 int num_planes) {
4058 AV1_COMMON *const cm = &cpi->common;
4059 const int tile_cols = cm->tiles.cols;
4060 TileDataEnc *this_tile = &cpi->tile_data[tile_row * tile_cols + tile_col];
4061 const TileInfo *const tile_info = &this_tile->tile_info;
4062
4063 const int tile_mb_cols =
4064 (tile_info->mi_col_end - tile_info->mi_col_start + 2) >> 2;
4065 const int tile_mb_row = (mi_row - tile_info->mi_row_start + 2) >> 2;
4066
4067 *tok = cpi->token_info.tile_tok[tile_row][tile_col] +
4068 get_token_alloc(tile_mb_row, tile_mb_cols, sb_size_log2, num_planes);
4069}
4070
4071void av1_apply_encoding_flags(AV1_COMP *cpi, aom_enc_frame_flags_t flags);
4072
4073#define ALT_MIN_LAG 3
4074static inline int is_altref_enabled(int lag_in_frames, bool enable_auto_arf) {
4075 return lag_in_frames >= ALT_MIN_LAG && enable_auto_arf;
4076}
4077
4078static inline int can_disable_altref(const GFConfig *gf_cfg) {
4079 return is_altref_enabled(gf_cfg->lag_in_frames, gf_cfg->enable_auto_arf) &&
4080 (gf_cfg->gf_min_pyr_height == 0);
4081}
4082
4083// Helper function to compute number of blocks on either side of the frame.
4084static inline int get_num_blocks(const int frame_length, const int mb_length) {
4085 return (frame_length + mb_length - 1) / mb_length;
4086}
4087
4088// Check if statistics generation stage
4089static inline int is_stat_generation_stage(const AV1_COMP *const cpi) {
4090 assert(IMPLIES(cpi->compressor_stage == LAP_STAGE,
4091 cpi->oxcf.pass == AOM_RC_ONE_PASS && cpi->ppi->lap_enabled));
4092 return (cpi->oxcf.pass == AOM_RC_FIRST_PASS ||
4093 (cpi->compressor_stage == LAP_STAGE));
4094}
4095// Check if statistics consumption stage
4096static inline int is_stat_consumption_stage_twopass(const AV1_COMP *const cpi) {
4097 return (cpi->oxcf.pass >= AOM_RC_SECOND_PASS);
4098}
4099
4100// Check if statistics consumption stage
4101static inline int is_stat_consumption_stage(const AV1_COMP *const cpi) {
4102 return (is_stat_consumption_stage_twopass(cpi) ||
4103 (cpi->oxcf.pass == AOM_RC_ONE_PASS &&
4104 (cpi->compressor_stage == ENCODE_STAGE) && cpi->ppi->lap_enabled));
4105}
4106
4107// Decide whether 'dv_costs' need to be allocated/stored during the encoding.
4108static inline bool av1_need_dv_costs(const AV1_COMP *const cpi) {
4109 return !cpi->sf.rt_sf.use_nonrd_pick_mode &&
4110 av1_allow_intrabc(&cpi->common) && !is_stat_generation_stage(cpi);
4111}
4112
4122static inline int has_no_stats_stage(const AV1_COMP *const cpi) {
4123 assert(
4124 IMPLIES(!cpi->ppi->lap_enabled, cpi->compressor_stage == ENCODE_STAGE));
4125 return (cpi->oxcf.pass == AOM_RC_ONE_PASS && !cpi->ppi->lap_enabled);
4126}
4127
4129
4130static inline int is_one_pass_rt_params(const AV1_COMP *cpi) {
4131 return has_no_stats_stage(cpi) && cpi->oxcf.gf_cfg.lag_in_frames == 0 &&
4132 (cpi->oxcf.mode == REALTIME || cpi->svc.number_spatial_layers > 1);
4133}
4134
4135// Use default/internal reference structure for single-layer RTC.
4136static inline int use_rtc_reference_structure_one_layer(const AV1_COMP *cpi) {
4137 return is_one_pass_rt_params(cpi) && cpi->ppi->number_spatial_layers == 1 &&
4138 cpi->ppi->number_temporal_layers == 1 &&
4139 !cpi->ppi->rtc_ref.set_ref_frame_config;
4140}
4141
4142// Check if postencode drop is allowed.
4143static inline int allow_postencode_drop_rtc(const AV1_COMP *cpi) {
4144 const AV1_COMMON *const cm = &cpi->common;
4145 return is_one_pass_rt_params(cpi) && cpi->oxcf.rc_cfg.mode == AOM_CBR &&
4147 !cpi->rc.rtc_external_ratectrl && !frame_is_intra_only(cm) &&
4148 cpi->svc.spatial_layer_id == 0;
4149}
4150
4151// Function return size of frame stats buffer
4152static inline int get_stats_buf_size(int num_lap_buffer, int num_lag_buffer) {
4153 /* if lookahead is enabled return num_lap_buffers else num_lag_buffers */
4154 return (num_lap_buffer > 0 ? num_lap_buffer + 1 : num_lag_buffer);
4155}
4156
4157// TODO(zoeliu): To set up cpi->oxcf.gf_cfg.enable_auto_brf
4158
4159static inline void set_ref_ptrs(const AV1_COMMON *cm, MACROBLOCKD *xd,
4160 MV_REFERENCE_FRAME ref0,
4161 MV_REFERENCE_FRAME ref1) {
4163 get_ref_scale_factors_const(cm, ref0 >= LAST_FRAME ? ref0 : 1);
4165 get_ref_scale_factors_const(cm, ref1 >= LAST_FRAME ? ref1 : 1);
4166}
4167
4168static inline int get_chessboard_index(int frame_index) {
4169 return frame_index & 0x1;
4170}
4171
4172static inline const int *cond_cost_list_const(const struct AV1_COMP *cpi,
4173 const int *cost_list) {
4174 const int use_cost_list = cpi->sf.mv_sf.subpel_search_method != SUBPEL_TREE &&
4175 cpi->sf.mv_sf.use_fullpel_costlist;
4176 return use_cost_list ? cost_list : NULL;
4177}
4178
4179static inline int *cond_cost_list(const struct AV1_COMP *cpi, int *cost_list) {
4180 const int use_cost_list = cpi->sf.mv_sf.subpel_search_method != SUBPEL_TREE &&
4181 cpi->sf.mv_sf.use_fullpel_costlist;
4182 return use_cost_list ? cost_list : NULL;
4183}
4184
4185// Compression ratio of current frame.
4186double av1_get_compression_ratio(const AV1_COMMON *const cm,
4187 size_t encoded_frame_size);
4188
4189void av1_new_framerate(AV1_COMP *cpi, double framerate);
4190
4191void av1_setup_frame_size(AV1_COMP *cpi);
4192
4193#define LAYER_IDS_TO_IDX(sl, tl, num_tl) ((sl) * (num_tl) + (tl))
4194
4195// Returns 1 if a frame is scaled and 0 otherwise.
4196static inline int av1_resize_scaled(const AV1_COMMON *cm) {
4197 return cm->superres_upscaled_width != cm->render_width ||
4199}
4200
4201static inline int av1_frame_scaled(const AV1_COMMON *cm) {
4202 return av1_superres_scaled(cm) || av1_resize_scaled(cm);
4203}
4204
4205// Don't allow a show_existing_frame to coincide with an error resilient
4206// frame. An exception can be made for a forward keyframe since it has no
4207// previous dependencies.
4208static inline int encode_show_existing_frame(const AV1_COMMON *cm) {
4210 cm->current_frame.frame_type == KEY_FRAME);
4211}
4212
4213// Get index into the 'cpi->mbmi_ext_info.frame_base' array for the given
4214// 'mi_row' and 'mi_col'.
4215static inline int get_mi_ext_idx(const int mi_row, const int mi_col,
4216 const BLOCK_SIZE mi_alloc_bsize,
4217 const int mbmi_ext_stride) {
4218 const int mi_ext_size_1d = mi_size_wide[mi_alloc_bsize];
4219 const int mi_ext_row = mi_row / mi_ext_size_1d;
4220 const int mi_ext_col = mi_col / mi_ext_size_1d;
4221 return mi_ext_row * mbmi_ext_stride + mi_ext_col;
4222}
4223
4224// Lighter version of set_offsets that only sets the mode info
4225// pointers.
4226static inline void set_mode_info_offsets(
4227 const CommonModeInfoParams *const mi_params,
4228 const MBMIExtFrameBufferInfo *const mbmi_ext_info, MACROBLOCK *const x,
4229 MACROBLOCKD *const xd, int mi_row, int mi_col) {
4230 set_mi_offsets(mi_params, xd, mi_row, mi_col);
4231 const int ext_idx = get_mi_ext_idx(mi_row, mi_col, mi_params->mi_alloc_bsize,
4232 mbmi_ext_info->stride);
4233 x->mbmi_ext_frame = mbmi_ext_info->frame_base + ext_idx;
4234}
4235
4236// Check to see if the given partition size is allowed for a specified number
4237// of mi block rows and columns remaining in the image.
4238// If not then return the largest allowed partition size
4239static inline BLOCK_SIZE find_partition_size(BLOCK_SIZE bsize, int rows_left,
4240 int cols_left, int *bh, int *bw) {
4241 int int_size = (int)bsize;
4242 if (rows_left <= 0 || cols_left <= 0) {
4243 return AOMMIN(bsize, BLOCK_8X8);
4244 } else {
4245 for (; int_size > 0; int_size -= 3) {
4246 *bh = mi_size_high[int_size];
4247 *bw = mi_size_wide[int_size];
4248 if ((*bh <= rows_left) && (*bw <= cols_left)) {
4249 break;
4250 }
4251 }
4252 }
4253 return (BLOCK_SIZE)int_size;
4254}
4255
4256static const uint8_t av1_ref_frame_flag_list[REF_FRAMES] = { 0,
4257 AOM_LAST_FLAG,
4258 AOM_LAST2_FLAG,
4259 AOM_LAST3_FLAG,
4260 AOM_GOLD_FLAG,
4261 AOM_BWD_FLAG,
4262 AOM_ALT2_FLAG,
4263 AOM_ALT_FLAG };
4264
4265// When more than 'max_allowed_refs' are available, we reduce the number of
4266// reference frames one at a time based on this order.
4267static const MV_REFERENCE_FRAME disable_order[] = {
4268 LAST3_FRAME,
4269 LAST2_FRAME,
4270 ALTREF2_FRAME,
4271 BWDREF_FRAME,
4272};
4273
4274static const MV_REFERENCE_FRAME
4275 ref_frame_priority_order[INTER_REFS_PER_FRAME] = {
4276 LAST_FRAME, ALTREF_FRAME, BWDREF_FRAME, GOLDEN_FRAME,
4277 ALTREF2_FRAME, LAST2_FRAME, LAST3_FRAME,
4278 };
4279
4280static inline int get_ref_frame_flags(const SPEED_FEATURES *const sf,
4281 const int use_one_pass_rt_params,
4282 const YV12_BUFFER_CONFIG **ref_frames,
4283 const int ext_ref_frame_flags) {
4284 // cpi->ext_flags.ref_frame_flags allows certain reference types to be
4285 // disabled by the external interface. These are set by
4286 // av1_apply_encoding_flags(). Start with what the external interface allows,
4287 // then suppress any reference types which we have found to be duplicates.
4288 int flags = ext_ref_frame_flags;
4289
4290 for (int i = 1; i < INTER_REFS_PER_FRAME; ++i) {
4291 const YV12_BUFFER_CONFIG *const this_ref = ref_frames[i];
4292 // If this_ref has appeared before, mark the corresponding ref frame as
4293 // invalid. For one_pass_rt mode, only disable GOLDEN_FRAME if it's the
4294 // same as LAST_FRAME or ALTREF_FRAME (if ALTREF is being used in nonrd).
4295 int index =
4296 (use_one_pass_rt_params && ref_frame_priority_order[i] == GOLDEN_FRAME)
4297 ? (1 + sf->rt_sf.use_nonrd_altref_frame)
4298 : i;
4299 for (int j = 0; j < index; ++j) {
4300 // If this_ref has appeared before (same as the reference corresponding
4301 // to lower index j), remove it as a reference only if that reference
4302 // (for index j) is actually used as a reference.
4303 if (this_ref == ref_frames[j] &&
4304 (flags & (1 << (ref_frame_priority_order[j] - 1)))) {
4305 flags &= ~(1 << (ref_frame_priority_order[i] - 1));
4306 break;
4307 }
4308 }
4309 }
4310 return flags;
4311}
4312
4313// Returns a Sequence Header OBU stored in an aom_fixed_buf_t, or NULL upon
4314// failure. When a non-NULL aom_fixed_buf_t pointer is returned by this
4315// function, the memory must be freed by the caller. Both the buf member of the
4316// aom_fixed_buf_t, and the aom_fixed_buf_t pointer itself must be freed. Memory
4317// returned must be freed via call to free().
4318//
4319// Note: The OBU returned is in Low Overhead Bitstream Format. Specifically,
4320// the obu_has_size_field bit is set, and the buffer contains the obu_size
4321// field.
4322aom_fixed_buf_t *av1_get_global_headers(AV1_PRIMARY *ppi);
4323
4324#define MAX_GFUBOOST_FACTOR 10.0
4325#define MIN_GFUBOOST_FACTOR 4.0
4326
4327static inline int is_frame_tpl_eligible(const GF_GROUP *const gf_group,
4328 uint8_t index) {
4329 const FRAME_UPDATE_TYPE update_type = gf_group->update_type[index];
4330 return update_type == ARF_UPDATE || update_type == GF_UPDATE ||
4331 update_type == KF_UPDATE;
4332}
4333
4334static inline int is_frame_eligible_for_ref_pruning(const GF_GROUP *gf_group,
4335 int selective_ref_frame,
4336 int prune_ref_frames,
4337 int gf_index) {
4338 return (selective_ref_frame > 0) && (prune_ref_frames > 0) &&
4339 !is_frame_tpl_eligible(gf_group, gf_index);
4340}
4341
4342// Get update type of the current frame.
4343static inline FRAME_UPDATE_TYPE get_frame_update_type(const GF_GROUP *gf_group,
4344 int gf_frame_index) {
4345 return gf_group->update_type[gf_frame_index];
4346}
4347
4348static inline int av1_pixels_to_mi(int pixels) {
4349 return ALIGN_POWER_OF_TWO(pixels, 3) >> MI_SIZE_LOG2;
4350}
4351
4352static inline int is_psnr_calc_enabled(const AV1_COMP *cpi) {
4353 const AV1_COMMON *const cm = &cpi->common;
4354
4355 return cpi->ppi->b_calculate_psnr && !is_stat_generation_stage(cpi) &&
4356 cm->show_frame && !cpi->is_dropped_frame;
4357}
4358
4359static inline int is_frame_resize_pending(const AV1_COMP *const cpi) {
4360 const ResizePendingParams *const resize_pending_params =
4362 return (resize_pending_params->width && resize_pending_params->height &&
4363 (cpi->common.width != resize_pending_params->width ||
4364 cpi->common.height != resize_pending_params->height));
4365}
4366
4367// Check if loop filter is used.
4368static inline int is_loopfilter_used(const AV1_COMMON *const cm) {
4369 return !cm->features.coded_lossless && !cm->tiles.large_scale;
4370}
4371
4372// Check if CDEF is used.
4373static inline int is_cdef_used(const AV1_COMMON *const cm) {
4374 return cm->seq_params->enable_cdef && !cm->features.coded_lossless &&
4375 !cm->tiles.large_scale;
4376}
4377
4378// Check if loop restoration filter is used.
4379static inline int is_restoration_used(const AV1_COMMON *const cm) {
4380 return cm->seq_params->enable_restoration && !cm->features.all_lossless &&
4381 !cm->tiles.large_scale;
4382}
4383
4384// Checks if post-processing filters need to be applied.
4385// NOTE: This function decides if the application of different post-processing
4386// filters on the reconstructed frame can be skipped at the encoder side.
4387// However the computation of different filter parameters that are signaled in
4388// the bitstream is still required.
4389static inline unsigned int derive_skip_apply_postproc_filters(
4390 const AV1_COMP *cpi, int use_loopfilter, int use_cdef, int use_superres,
4391 int use_restoration) {
4392 // Though CDEF parameter selection should be dependent on
4393 // deblocked/loop-filtered pixels for cdef_pick_method <=
4394 // CDEF_FAST_SEARCH_LVL5, CDEF strength values are calculated based on the
4395 // pixel values that are not loop-filtered in svc real-time encoding mode.
4396 // Hence this case is handled separately using the condition below.
4397 if (cpi->ppi->rtc_ref.non_reference_frame)
4398 return (SKIP_APPLY_LOOPFILTER | SKIP_APPLY_CDEF);
4399
4401 return 0;
4402 assert(cpi->oxcf.mode == ALLINTRA);
4403
4404 // The post-processing filters are applied one after the other in the
4405 // following order: deblocking->cdef->superres->restoration. In case of
4406 // ALLINTRA encoding, the reconstructed frame is not used as a reference
4407 // frame. Hence, the application of these filters can be skipped when
4408 // 1. filter parameters of the subsequent stages are not dependent on the
4409 // filtered output of the current stage or
4410 // 2. subsequent filtering stages are disabled
4411 if (use_restoration) return SKIP_APPLY_RESTORATION;
4412 if (use_superres) return SKIP_APPLY_SUPERRES;
4413 if (use_cdef) {
4414 // CDEF parameter selection is not dependent on the deblocked frame if
4415 // cdef_pick_method is CDEF_PICK_FROM_Q. Hence the application of deblocking
4416 // filters and cdef filters can be skipped in this case.
4417 return (cpi->sf.lpf_sf.cdef_pick_method == CDEF_PICK_FROM_Q &&
4418 use_loopfilter)
4419 ? (SKIP_APPLY_LOOPFILTER | SKIP_APPLY_CDEF)
4420 : SKIP_APPLY_CDEF;
4421 }
4422 if (use_loopfilter) return SKIP_APPLY_LOOPFILTER;
4423
4424 // If we reach here, all post-processing stages are disabled, so none need to
4425 // be skipped.
4426 return 0;
4427}
4428
4429static inline void set_postproc_filter_default_params(AV1_COMMON *cm) {
4430 struct loopfilter *const lf = &cm->lf;
4431 CdefInfo *const cdef_info = &cm->cdef_info;
4432 RestorationInfo *const rst_info = cm->rst_info;
4433
4434 lf->filter_level[0] = 0;
4435 lf->filter_level[1] = 0;
4436 lf->backup_filter_level[0] = 0;
4437 lf->backup_filter_level[1] = 0;
4438 cdef_info->cdef_bits = 0;
4439 cdef_info->cdef_strengths[0] = 0;
4440 cdef_info->nb_cdef_strengths = 1;
4441 cdef_info->cdef_uv_strengths[0] = 0;
4445}
4446
4447static inline int is_inter_tx_size_search_level_one(
4448 const TX_SPEED_FEATURES *tx_sf) {
4449 return (tx_sf->inter_tx_size_search_init_depth_rect >= 1 &&
4450 tx_sf->inter_tx_size_search_init_depth_sqr >= 1);
4451}
4452
4453static inline int get_lpf_opt_level(const SPEED_FEATURES *sf) {
4454 int lpf_opt_level = 0;
4455 if (is_inter_tx_size_search_level_one(&sf->tx_sf))
4456 lpf_opt_level = (sf->lpf_sf.lpf_pick == LPF_PICK_FROM_Q) ? 2 : 1;
4457 return lpf_opt_level;
4458}
4459
4460// Enable switchable motion mode only if warp and OBMC tools are allowed
4461static inline bool is_switchable_motion_mode_allowed(bool allow_warped_motion,
4462 bool enable_obmc) {
4463 return (allow_warped_motion || enable_obmc);
4464}
4465
4466#if CONFIG_AV1_TEMPORAL_DENOISING
4467static inline int denoise_svc(const struct AV1_COMP *const cpi) {
4468 return (!cpi->ppi->use_svc ||
4469 (cpi->ppi->use_svc &&
4470 cpi->svc.spatial_layer_id >= cpi->svc.first_layer_denoise));
4471}
4472#endif
4473
4474#if CONFIG_COLLECT_PARTITION_STATS == 2
4475static inline void av1_print_fr_partition_timing_stats(
4476 const FramePartitionTimingStats *part_stats, const char *filename) {
4477 FILE *f = fopen(filename, "w");
4478 if (!f) {
4479 return;
4480 }
4481
4482 fprintf(f, "bsize,redo,");
4483 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4484 fprintf(f, "decision_%d,", part);
4485 }
4486 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4487 fprintf(f, "attempt_%d,", part);
4488 }
4489 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4490 fprintf(f, "time_%d,", part);
4491 }
4492 fprintf(f, "\n");
4493
4494 static const int bsizes[6] = { 128, 64, 32, 16, 8, 4 };
4495
4496 for (int bsize_idx = 0; bsize_idx < 6; bsize_idx++) {
4497 fprintf(f, "%d,%d,", bsizes[bsize_idx], part_stats->partition_redo);
4498 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4499 fprintf(f, "%d,", part_stats->partition_decisions[bsize_idx][part]);
4500 }
4501 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4502 fprintf(f, "%d,", part_stats->partition_attempts[bsize_idx][part]);
4503 }
4504 for (int part = 0; part < EXT_PARTITION_TYPES; part++) {
4505 fprintf(f, "%ld,", part_stats->partition_times[bsize_idx][part]);
4506 }
4507 fprintf(f, "\n");
4508 }
4509 fclose(f);
4510}
4511#endif // CONFIG_COLLECT_PARTITION_STATS == 2
4512
4513#if CONFIG_COLLECT_PARTITION_STATS
4514static inline int av1_get_bsize_idx_for_part_stats(BLOCK_SIZE bsize) {
4515 assert(bsize == BLOCK_128X128 || bsize == BLOCK_64X64 ||
4516 bsize == BLOCK_32X32 || bsize == BLOCK_16X16 || bsize == BLOCK_8X8 ||
4517 bsize == BLOCK_4X4);
4518 switch (bsize) {
4519 case BLOCK_128X128: return 0;
4520 case BLOCK_64X64: return 1;
4521 case BLOCK_32X32: return 2;
4522 case BLOCK_16X16: return 3;
4523 case BLOCK_8X8: return 4;
4524 case BLOCK_4X4: return 5;
4525 default: assert(0 && "Invalid bsize for partition_stats."); return -1;
4526 }
4527}
4528#endif // CONFIG_COLLECT_PARTITION_STATS
4529
4530#if CONFIG_COLLECT_COMPONENT_TIMING
4531static inline void start_timing(AV1_COMP *cpi, int component) {
4532 aom_usec_timer_start(&cpi->component_timer[component]);
4533}
4534static inline void end_timing(AV1_COMP *cpi, int component) {
4535 aom_usec_timer_mark(&cpi->component_timer[component]);
4536 cpi->frame_component_time[component] +=
4537 aom_usec_timer_elapsed(&cpi->component_timer[component]);
4538}
4539static inline char const *get_frame_type_enum(int type) {
4540 switch (type) {
4541 case 0: return "KEY_FRAME";
4542 case 1: return "INTER_FRAME";
4543 case 2: return "INTRA_ONLY_FRAME";
4544 case 3: return "S_FRAME";
4545 default: assert(0);
4546 }
4547 return "error";
4548}
4549#endif
4550
4552
4553#ifdef __cplusplus
4554} // extern "C"
4555#endif
4556
4557#endif // AOM_AV1_ENCODER_ENCODER_H_
enum aom_chroma_sample_position aom_chroma_sample_position_t
List of chroma sample positions.
enum aom_transfer_characteristics aom_transfer_characteristics_t
List of supported transfer functions.
enum aom_color_range aom_color_range_t
List of supported color range.
enum aom_color_primaries aom_color_primaries_t
List of supported color primaries.
enum aom_matrix_coefficients aom_matrix_coefficients_t
List of supported matrix coefficients.
Provides definitions for using AOM or AV1 encoder algorithm within the aom Codec Interface.
struct macroblock MACROBLOCK
Encoder's parameters related to the current coding block.
COST_UPDATE_TYPE
This enum controls how often the entropy costs should be updated.
Definition encoder.h:222
@ COST_UPD_SBROW
Definition encoder.h:224
@ COST_UPD_TILE
Definition encoder.h:225
@ COST_UPD_OFF
Definition encoder.h:226
@ NUM_COST_UPDATE_TYPES
Definition encoder.h:227
@ COST_UPD_SB
Definition encoder.h:223
LOOPFILTER_CONTROL
This enum controls to which frames loopfilter is applied.
Definition encoder.h:233
@ LOOPFILTER_ALL
Definition encoder.h:235
@ LOOPFILTER_SELECTIVELY
Definition encoder.h:237
@ LOOPFILTER_REFERENCE
Definition encoder.h:236
@ LOOPFILTER_NONE
Definition encoder.h:234
#define NUM_RECODES_PER_FRAME
Max number of recodes used to track the frame probabilities.
Definition encoder.h:1639
struct inter_modes_info InterModesInfo
Struct used to hold inter mode data for fast tx search.
SKIP_APPLY_POSTPROC_FILTER
This enum controls the application of post-processing filters on a reconstructed frame.
Definition encoder.h:245
#define MAX_PARALLEL_FRAMES
Max number of frames that can be encoded in a parallel encode set.
Definition encoder.h:1644
RestorationType
This enumeration defines various restoration types supported.
Definition enums.h:609
@ RESTORE_NONE
Definition enums.h:610
@ RESTORE_SWITCHABLE_TYPES
Definition enums.h:614
@ RESTORE_TYPES
Definition enums.h:615
aom_dist_metric
Distortion metric to use for RD optimization.
Definition aomcx.h:1750
aom_tune_content
AV1 encoder content type.
Definition aomcx.h:1677
enum aom_scaling_mode_1d AOM_SCALING_MODE
aom 1-D scaling mode
aom_tune_metric
Model tuning parameters.
Definition aomcx.h:1717
struct aom_roi_map aom_roi_map_t
aom region of interest map
aom_screen_detection_mode
Screen content detection mode.
Definition aomcx.h:1685
enum aom_bit_depth aom_bit_depth_t
Bit depth for codecThis enumeration determines the bit depth of the codec.
enum aom_superblock_size aom_superblock_size_t
Superblock size selection.
aom_codec_err_t
Algorithm return codes.
Definition aom_codec.h:155
aom_superres_mode
Frame super-resolution mode.
Definition aom_encoder.h:207
aom_rc_mode
Rate control mode.
Definition aom_encoder.h:185
aom_enc_pass
Multi-pass Encoding Pass.
Definition aom_encoder.h:176
struct aom_fixed_buf aom_fixed_buf_t
Generic fixed size buffer structure.
long aom_enc_frame_flags_t
Encoded Frame Flags.
Definition aom_encoder.h:377
@ AOM_CBR
Definition aom_encoder.h:187
@ AOM_RC_ONE_PASS
Definition aom_encoder.h:177
@ AOM_RC_SECOND_PASS
Definition aom_encoder.h:179
@ AOM_RC_FIRST_PASS
Definition aom_encoder.h:178
int av1_get_compressed_data(AV1_COMP *cpi, AV1_COMP_DATA *const cpi_data)
Encode a frame.
Definition encoder.c:5160
int av1_encode(AV1_COMP *const cpi, uint8_t *const dest, size_t dest_size, const EncodeFrameInput *const frame_input, const EncodeFrameParams *const frame_params, size_t *const frame_size)
Run 1-pass/2-pass encoding.
Definition encoder.c:4452
int av1_receive_raw_frame(AV1_COMP *cpi, aom_enc_frame_flags_t frame_flags, const YV12_BUFFER_CONFIG *sd, int64_t time_stamp, int64_t end_time_stamp)
Obtain the raw frame data.
Definition encoder.c:4550
static int has_no_stats_stage(const AV1_COMP *const cpi)
Check if the current stage has statistics.
Definition encoder.h:4122
Describes look ahead buffer operations.
@ CDEF_PICK_FROM_Q
Definition speed_features.h:172
RestorationInfo rst_info[3]
Definition av1_common_int.h:960
int superres_upscaled_width
Definition av1_common_int.h:813
int superres_upscaled_height
Definition av1_common_int.h:814
SequenceHeader * seq_params
Definition av1_common_int.h:990
int width
Definition av1_common_int.h:789
CdefInfo cdef_info
Definition av1_common_int.h:969
CurrentFrame current_frame
Definition av1_common_int.h:768
int show_existing_frame
Definition av1_common_int.h:914
struct loopfilter lf
Definition av1_common_int.h:953
FeatureFlags features
Definition av1_common_int.h:919
int show_frame
Definition av1_common_int.h:899
RefCntBuffer * ref_frame_map[REF_FRAMES]
Definition av1_common_int.h:892
CommonTileParams tiles
Definition av1_common_int.h:1006
int height
Definition av1_common_int.h:790
int render_width
Definition av1_common_int.h:800
int render_height
Definition av1_common_int.h:801
Encoder data related to multi-threading for allintra deltaq-mode=3.
Definition encoder.h:1609
pthread_mutex_t * mutex_
Definition encoder.h:1614
void(* intra_sync_read_ptr)(AV1EncRowMultiThreadSync *const, int, int)
Definition encoder.h:1628
pthread_cond_t * cond_
Definition encoder.h:1618
void(* intra_sync_write_ptr)(AV1EncRowMultiThreadSync *const, int, int, int)
Definition encoder.h:1632
Encoder data related to row-based multi-threading.
Definition encoder.h:1519
int allocated_sb_rows
Definition encoder.h:1558
pthread_mutex_t * mutex_
Definition encoder.h:1584
int allocated_tile_cols
Definition encoder.h:1527
bool firstpass_mt_exit
Definition encoder.h:1571
int allocated_cols
Definition encoder.h:1541
int thread_id_to_tile_id[64]
Definition encoder.h:1546
bool mb_wiener_mt_exit
Definition encoder.h:1578
void(* sync_write_ptr)(AV1EncRowMultiThreadSync *const, int, int, int)
Definition encoder.h:1602
pthread_cond_t * cond_
Definition encoder.h:1588
bool row_mt_exit
Definition encoder.h:1564
int allocated_tile_rows
Definition encoder.h:1523
int allocated_rows
Definition encoder.h:1534
int * num_tile_cols_done
Definition encoder.h:1552
void(* sync_read_ptr)(AV1EncRowMultiThreadSync *const, int, int)
Definition encoder.h:1598
Encoder parameters for synchronization of row based multi-threading.
Definition encoder.h:1401
int rows
Definition encoder.h:1434
int sync_range
Definition encoder.h:1423
int intrabc_extra_top_right_sb_delay
Definition encoder.h:1430
int next_mi_row
Definition encoder.h:1438
int * num_finished_cols
Definition encoder.h:1416
pthread_mutex_t * mutex_
Definition encoder.h:1407
pthread_cond_t * cond_
Definition encoder.h:1408
int num_threads_working
Definition encoder.h:1442
Main encoder configuration data structure.
Definition encoder.h:938
RateControlCfg rc_cfg
Definition encoder.h:960
KeyFrameCfg kf_cfg
Definition encoder.h:955
enum aom_enc_pass pass
Definition encoder.h:1066
AlgoCfg algo_cfg
Definition encoder.h:950
aom_fixed_buf_t twopass_stats_in
Definition encoder.h:977
Structure to hold search parameter per restoration unit and intermediate buffer of Wiener filter used...
Definition encoder.h:1698
RestUnitSearchInfo * rusi[3]
Definition encoder.h:1703
int16_t * dgd_avg
Definition encoder.h:1708
Structure to hold data corresponding to an encoded frame.
Definition encoder.h:2540
int64_t ts_frame_end
Definition encoder.h:2569
int pop_lookahead
Definition encoder.h:2584
int64_t ts_frame_start
Definition encoder.h:2564
unsigned char * cx_data
Definition encoder.h:2544
size_t cx_data_sz
Definition encoder.h:2549
int flush
Definition encoder.h:2574
unsigned int lib_flags
Definition encoder.h:2559
size_t frame_size
Definition encoder.h:2554
const aom_rational64_t * timestamp_ratio
Definition encoder.h:2579
Top level encoder structure.
Definition encoder.h:2890
double * ext_rate_distribution
Definition encoder.h:3567
int do_update_frame_probs_warp[10]
Definition encoder.h:3276
uint8_t * consec_zero_mv
Definition encoder.h:3477
int do_update_frame_probs_obmc[10]
Definition encoder.h:3271
struct aom_denoise_and_model_t * denoise_and_model
Definition encoder.h:3344
int skip_tpl_setup_stats
Definition encoder.h:2998
int frames_since_last_update
Definition encoder.h:3653
int * mb_delta_q
Definition encoder.h:3587
int vaq_refresh
Definition encoder.h:3246
FRAME_TYPE last_frame_type
Definition encoder.h:3442
YV12_BUFFER_CONFIG * unscaled_source
Definition encoder.h:2966
int palette_pixel_num
Definition encoder.h:3682
CYCLIC_REFRESH * cyclic_refresh
Definition encoder.h:3138
RATE_CONTROL rc
Definition encoder.h:3097
int deltaq_used
Definition encoder.h:3400
ActiveMap active_map
Definition encoder.h:3143
bool frame_size_related_setup_done
Definition encoder.h:3209
WeberStats * mb_weber_stats
Definition encoder.h:3555
bool refresh_idx_available
Definition encoder.h:3520
TokenInfo token_info
Definition encoder.h:3241
int64_t ambient_err
Definition encoder.h:3066
aom_film_grain_table_t * film_grain_table
Definition encoder.h:3337
int ref_refresh_index
Definition encoder.h:3514
size_t available_bs_size
Definition encoder.h:3498
SPEED_FEATURES sf
Definition encoder.h:3117
TRELLIS_OPT_TYPE optimize_seg_arr[8]
Definition encoder.h:2944
ExtPartController ext_part_controller
Definition encoder.h:3504
FILE * second_pass_log_stream
Definition encoder.h:3623
double * ssim_rdmult_scaling_factors
Definition encoder.h:3412
RD_OPT rd
Definition encoder.h:3071
int data_alloc_height
Definition encoder.h:3195
int num_tg
Definition encoder.h:3447
WinnerModeParams winner_mode_params
Definition encoder.h:3087
ExternalFlags ext_flags
Definition encoder.h:3049
bool alloc_pyramid
Definition encoder.h:3664
EncSegmentationInfo enc_seg
Definition encoder.h:3133
MotionVectorSearchParams mv_search_params
Definition encoder.h:3122
int use_screen_content_tools
Definition encoder.h:3359
int do_update_frame_probs_interpfilter[10]
Definition encoder.h:3281
CODING_CONTEXT coding_context
Definition encoder.h:3077
TemporalFilterCtx tf_ctx
Definition encoder.h:3013
ForceIntegerMVInfo force_intpel_info
Definition encoder.h:3023
GlobalMotionInfo gm_info
Definition encoder.h:3082
int consec_zero_mv_alloc_size
Definition encoder.h:3482
CoeffBufferPool coeff_buffer_pool
Definition encoder.h:2928
FRAME_INDEX_SET frame_index_set
Definition encoder.h:3181
int ref_frame_flags
Definition encoder.h:3107
RefCntBuffer * scaled_ref_buf[INTER_REFS_PER_FRAME]
Definition encoder.h:3029
unsigned char gf_frame_index
Definition encoder.h:3148
AV1EncoderConfig oxcf
Definition encoder.h:2938
AV1_COMMON common
Definition encoder.h:2933
AV1LrStruct lr_ctxt
Definition encoder.h:3327
bool do_frame_data_update
Definition encoder.h:3543
CdefSearchCtx * cdef_search_ctx
Definition encoder.h:3018
int data_alloc_width
Definition encoder.h:3188
int do_update_frame_probs_txtype[10]
Definition encoder.h:3266
FRAME_COUNTS counts
Definition encoder.h:2910
COMPRESSOR_STAGE compressor_stage
Definition encoder.h:3436
int intrabc_used
Definition encoder.h:3317
int num_frame_recode
Definition encoder.h:3256
int rt_reduce_num_ref_buffers
Definition encoder.h:3044
RefreshFrameInfo refresh_frame
Definition encoder.h:3039
int prune_ref_frame_mask
Definition encoder.h:3322
YV12_BUFFER_CONFIG * unscaled_last_source
Definition encoder.h:2976
int all_one_sided_refs
Definition encoder.h:3128
MultiThreadInfo mt_info
Definition encoder.h:3305
VarBasedPartitionInfo vbp_info
Definition encoder.h:3251
int scaled_last_source_available
Definition encoder.h:3688
YV12_BUFFER_CONFIG * last_source
Definition encoder.h:2960
int existing_fb_idx_to_show
Definition encoder.h:3312
YV12_BUFFER_CONFIG * unfiltered_source
Definition encoder.h:2987
unsigned int zeromv_skip_thresh_exit_part[BLOCK_SIZES_ALL]
Definition encoder.h:3658
FRAME_INFO frame_info
Definition encoder.h:3176
int last_coded_height
Definition encoder.h:3221
int frame_header_count
Definition encoder.h:3395
int droppable
Definition encoder.h:3171
RefCntBuffer * last_show_frame_buf
Definition encoder.h:3034
aom_superres_mode superres_mode
Definition encoder.h:3454
MBMIExtFrameBufferInfo mbmi_ext_info
Definition encoder.h:2915
AV1LrPickStruct pick_lr_ctxt
Definition encoder.h:3332
double new_framerate
Definition encoder.h:3295
AV1_PRIMARY * ppi
Definition encoder.h:2894
uint64_t * src_sad_blk_64x64
Definition encoder.h:3628
int64_t norm_wiener_variance
Definition encoder.h:3582
double * tpl_rdmult_scaling_factors
Definition encoder.h:3008
int sb_counter
Definition encoder.h:3493
int last_coded_width
Definition encoder.h:3215
TileDataEnc * tile_data
Definition encoder.h:3232
int is_screen_content_type
Definition encoder.h:3367
BLOCK_SIZE weber_bsize
Definition encoder.h:3577
InterpSearchFlags interp_search_flags
Definition encoder.h:3350
TimeStamps time_stamps
Definition encoder.h:3092
aom_roi_map_t roi
Definition encoder.h:3693
int ref_idx_to_skip
Definition encoder.h:3527
YV12_BUFFER_CONFIG orig_source
Definition encoder.h:2993
FirstPassData firstpass_data
Definition encoder.h:3459
double framerate
Definition encoder.h:3102
int speed
Definition encoder.h:3112
BLOCK_SIZE fp_block_size
Definition encoder.h:3487
int use_ducky_encode
Definition encoder.h:3641
YV12_BUFFER_CONFIG trial_frame_rst
Definition encoder.h:3061
bool is_dropped_frame
Definition encoder.h:3592
ThreadData td
Definition encoder.h:2905
ResizePendingParams resize_pending_params
Definition encoder.h:3226
YV12_BUFFER_CONFIG scaled_source
Definition encoder.h:2971
int do_update_vbr_bits_off_target_fast
Definition encoder.h:3300
YV12_BUFFER_CONFIG last_frame_uf
Definition encoder.h:3055
EncQuantDequantParams enc_quant_dequant_params
Definition encoder.h:2900
RefFrameDistanceInfo ref_frame_dist_info
Definition encoder.h:3405
int * prep_rate_estimates
Definition encoder.h:3561
DuckyEncodeInfo ducky_encode_info
Definition encoder.h:3647
double ext_rate_scale
Definition encoder.h:3572
int initial_mbs
Definition encoder.h:3203
uint64_t rec_sse
Definition encoder.h:3635
YV12_BUFFER_CONFIG scaled_last_source
Definition encoder.h:2981
MV_STATS mv_stats
Definition encoder.h:3510
FrameProbInfo frame_new_probs[10]
Definition encoder.h:3261
YV12_BUFFER_CONFIG * source
Definition encoder.h:2951
int allocated_tiles
Definition encoder.h:3236
SVC svc
Definition encoder.h:3431
CB_COEFF_BUFFER * coeff_buffer_base
Definition encoder.h:2922
NOISE_ESTIMATE noise_estimate
Definition encoder.h:3464
TWO_PASS_FRAME twopass_frame
Definition encoder.h:3611
Top level primary encoder structure.
Definition encoder.h:2590
int num_fp_contexts
Definition encoder.h:2647
AV1EncRowMultiThreadSync intra_row_mt_sync
Definition encoder.h:2884
bool buffer_removal_time_present
Definition encoder.h:2765
int valid_gm_model_found[FRAME_UPDATE_TYPES]
Definition encoder.h:2873
struct aom_codec_pkt_list * output_pkt_list
Definition encoder.h:2695
int filter_level[2]
Definition encoder.h:2652
SequenceHeader seq_params
Definition encoder.h:2755
MV_STATS mv_stats
Definition encoder.h:2803
struct AV1_COMP * cpi
Definition encoder.h:2668
AV1LevelParams level_params
Definition encoder.h:2725
int internal_altref_allowed
Definition encoder.h:2700
RTC_REF rtc_ref
Definition encoder.h:2878
int b_calculate_psnr
Definition encoder.h:2730
PrimaryMultiThreadInfo p_mt_info
Definition encoder.h:2860
TEMPORAL_FILTER_INFO tf_info
Definition encoder.h:2750
TWO_PASS twopass
Definition encoder.h:2740
int frames_left
Definition encoder.h:2735
int64_t ts_start_last_show_frame
Definition encoder.h:2637
PRIMARY_RATE_CONTROL p_rc
Definition encoder.h:2745
int lap_enabled
Definition encoder.h:2720
FrameProbInfo frame_probs
Definition encoder.h:2865
int show_existing_alt_ref
Definition encoder.h:2705
int fb_of_context_type[REF_FRAMES]
Definition encoder.h:2855
int use_svc
Definition encoder.h:2760
double * tpl_sb_rdmult_scaling_factors
Definition encoder.h:2793
int filter_level_v
Definition encoder.h:2662
int filter_level_u
Definition encoder.h:2657
struct AV1_COMP * cpi_lap
Definition encoder.h:2673
struct AV1_COMP * parallel_cpi[4]
Definition encoder.h:2594
int64_t ts_end_last_show_frame
Definition encoder.h:2642
struct lookahead_ctx * lookahead
Definition encoder.h:2678
RefCntBuffer * ref_frame_map_copy[REF_FRAMES]
Definition encoder.h:2632
GF_STATE gf_state
Definition encoder.h:2715
aom_variance_fn_ptr_t fn_ptr[BLOCK_SIZES_ALL]
Definition encoder.h:2787
GF_GROUP gf_group
Definition encoder.h:2710
struct AV1_COMP_DATA parallel_frames_data[4 - 1]
Definition encoder.h:2600
TplParams tpl_data
Definition encoder.h:2798
unsigned int number_temporal_layers
Definition encoder.h:2770
unsigned int number_spatial_layers
Definition encoder.h:2775
int seq_params_locked
Definition encoder.h:2689
struct aom_internal_error_info error
Definition encoder.h:2780
Algorithm configuration parameters.
Definition encoder.h:821
int disable_trellis_quant
Definition encoder.h:843
int sharpness
Definition encoder.h:834
bool skip_postproc_filtering
Definition encoder.h:887
int arnr_max_frames
Definition encoder.h:848
aom_screen_detection_mode screen_detection_mode
Definition encoder.h:892
bool enable_tpl_model
Definition encoder.h:866
LOOPFILTER_CONTROL loopfilter_control
Definition encoder.h:881
uint8_t cdf_update_mode
Definition encoder.h:861
bool enable_overlay
Definition encoder.h:872
int arnr_strength
Definition encoder.h:853
Stores the transforms coefficients for the whole superblock.
Definition block.h:206
The stucture of CYCLIC_REFRESH.
Definition aq_cyclicrefresh.h:36
Parameters related to CDEF.
Definition av1_common_int.h:202
int cdef_bits
Number of CDEF strength values in bits.
Definition av1_common_int.h:224
int cdef_uv_strengths[16]
CDEF strength values for chroma.
Definition av1_common_int.h:222
int cdef_strengths[16]
CDEF strength values for luma.
Definition av1_common_int.h:220
int nb_cdef_strengths
Number of CDEF strength values.
Definition av1_common_int.h:218
Definition encoder.h:2446
uint8_t * entropy_ctx
Definition encoder.h:2458
tran_low_t * tcoeff
Definition encoder.h:2450
uint16_t * eobs
Definition encoder.h:2454
Params related to MB_MODE_INFO arrays and related info.
Definition av1_common_int.h:510
BLOCK_SIZE mi_alloc_bsize
Definition av1_common_int.h:559
int cols
Definition av1_common_int.h:437
unsigned int large_scale
Definition av1_common_int.h:497
Encoder flags for compound prediction modes.
Definition encoder.h:400
bool enable_masked_comp
Definition encoder.h:409
bool enable_diff_wtd_comp
Definition encoder.h:417
bool enable_smooth_interintra
Definition encoder.h:413
bool enable_interintra_wedge
Definition encoder.h:425
bool enable_interinter_wedge
Definition encoder.h:421
bool enable_dist_wtd_comp
Definition encoder.h:404
Segmentation related information for the current frame.
Definition encoder.h:2409
uint8_t * map
Definition encoder.h:2415
bool has_lossless_segment
Definition encoder.h:2421
Input frames and last input frame.
Definition encoder.h:3699
contains per-frame encoding parameters decided upon by av1_encode_strategy() and passed down to av1_e...
Definition encoder.h:3711
int error_resilient_mode
Definition encoder.h:3715
int remapped_ref_idx[REF_FRAMES]
Definition encoder.h:3746
int ref_frame_flags
Definition encoder.h:3741
int speed
Definition encoder.h:3757
FRAME_TYPE frame_type
Definition encoder.h:3719
int show_frame
Definition encoder.h:3729
RefreshFrameInfo refresh_frame
Definition encoder.h:3752
Frame refresh flags set by the external interface.
Definition encoder.h:2276
bool golden_frame
Definition encoder.h:2278
bool bwd_ref_frame
Definition encoder.h:2279
bool update_pending
Definition encoder.h:2285
bool last_frame
Definition encoder.h:2277
bool alt_ref_frame
Definition encoder.h:2281
bool alt2_ref_frame
Definition encoder.h:2280
Flags signalled by the external interface at frame level.
Definition encoder.h:2291
bool use_primary_ref_none
Definition encoder.h:2332
bool use_ref_frame_mvs
Definition encoder.h:2316
ExtRefreshFrameFlagsInfo refresh_frame
Definition encoder.h:2300
int ref_frame_flags
Definition encoder.h:2295
bool use_error_resilient
Definition encoder.h:2321
bool use_s_frame
Definition encoder.h:2326
bool refresh_frame_context
Definition encoder.h:2305
bool refresh_frame_context_pending
Definition encoder.h:2311
Frame level features.
Definition av1_common_int.h:367
bool allow_screen_content_tools
Definition av1_common_int.h:384
bool allow_intrabc
Definition av1_common_int.h:385
bool coded_lossless
Definition av1_common_int.h:394
bool error_resilient_mode
Definition av1_common_int.h:409
bool all_lossless
Definition av1_common_int.h:398
Encoder info used for decision on forcing integer motion vectors.
Definition encoder.h:1870
double cs_rate_array[32]
Definition encoder.h:1875
int rate_size
Definition encoder.h:1883
int rate_index
Definition encoder.h:1879
Encoder-side probabilities for pruning of various AV1 tools.
Definition encoder.h:1129
int switchable_interp_probs[FRAME_UPDATE_TYPES][((SWITCHABLE_FILTERS+1) *4)][SWITCHABLE_FILTERS]
Definition encoder.h:1159
int obmc_probs[FRAME_UPDATE_TYPES][BLOCK_SIZES_ALL]
Definition encoder.h:1135
int warped_probs[FRAME_UPDATE_TYPES]
Definition encoder.h:1142
int tx_type_probs[FRAME_UPDATE_TYPES][TX_SIZES_ALL][TX_TYPES]
Definition encoder.h:1150
Data related to the current GF/ARF group and the individual frames within the group.
Definition firstpass.h:339
Parameters related to global motion search.
Definition encoder.h:2079
FrameDistPair reference_frames[2][REF_FRAMES - 1]
Definition encoder.h:2105
bool search_done
Definition encoder.h:2083
int segment_map_h
Definition encoder.h:2112
int num_ref_frames[2]
Definition encoder.h:2097
YV12_BUFFER_CONFIG * ref_buf[REF_FRAMES]
Definition encoder.h:2090
int segment_map_w
Definition encoder.h:2111
Flags related to interpolation filter search.
Definition encoder.h:2119
int default_interp_skip_flags
Definition encoder.h:2124
uint16_t interp_filter_search_mask
Definition encoder.h:2128
Encoder flags for intra prediction.
Definition encoder.h:303
bool enable_diagonal_intra
Definition encoder.h:333
bool enable_smooth_intra
Definition encoder.h:316
bool auto_intra_tools_off
Definition encoder.h:352
bool enable_filter_intra
Definition encoder.h:312
bool enable_directional_intra
Definition encoder.h:328
bool enable_paeth_intra
Definition encoder.h:320
bool enable_intra_edge_filter
Definition encoder.h:307
bool enable_cfl_intra
Definition encoder.h:324
bool enable_angle_delta
Definition encoder.h:338
Encoder config related to the coding of key frames.
Definition encoder.h:467
int key_freq_max
Definition encoder.h:476
int sframe_mode
Definition encoder.h:494
bool auto_key
Definition encoder.h:499
bool enable_intrabc
Definition encoder.h:519
int sframe_dist
Definition encoder.h:487
bool enable_sframe
Definition encoder.h:514
int enable_keyframe_filtering
Definition encoder.h:481
int fwd_kf_dist
Definition encoder.h:504
int key_freq_min
Definition encoder.h:471
bool fwd_kf_enabled
Definition encoder.h:509
Buffer to store mode information at mi_alloc_bsize (4x4 or 8x8) level.
Definition encoder.h:1916
int alloc_size
Definition encoder.h:1925
int stride
Definition encoder.h:1929
MB_MODE_INFO_EXT_FRAME * frame_base
Definition encoder.h:1921
Stores best extended mode information at frame level.
Definition block.h:242
Stores the prediction/txfm mode of the current coding block.
Definition blockd.h:222
Parameters for motion vector search process.
Definition encoder.h:2134
int max_mv_magnitude
Definition encoder.h:2140
fractional_mv_step_fp * find_fractional_mv_step
Definition encoder.h:2154
int mv_step_param
Definition encoder.h:2145
search_site_config search_site_cfg[SS_CFG_TOTAL][NUM_DISTINCT_SEARCH_METHODS]
Definition encoder.h:2161
Encoder parameters related to multi-threading.
Definition encoder.h:1761
RestoreStateBuffers restore_state_buf
Definition encoder.h:1848
AV1CdefWorkerData * cdef_worker
Definition encoder.h:1843
AV1LrSync lr_row_sync
Definition encoder.h:1818
struct EncWorkerData * tile_thr_data
Definition encoder.h:1781
AV1TplRowMultiThreadInfo tpl_row_mt
Definition encoder.h:1808
AV1EncPackBSSync pack_bs_sync
Definition encoder.h:1823
AV1EncRowMultiThreadInfo enc_row_mt
Definition encoder.h:1797
AV1LfSync lf_row_sync
Definition encoder.h:1813
AV1CdefSync cdef_sync
Definition encoder.h:1838
int num_mod_workers[NUM_MT_MODULES]
Definition encoder.h:1770
AV1EncAllIntraMultiThreadInfo intra_mt
Definition encoder.h:1803
int num_workers
Definition encoder.h:1765
int pipeline_lpf_mt_with_enc
Definition encoder.h:1854
AVxWorker * workers
Definition encoder.h:1775
bool pack_bs_mt_enabled
Definition encoder.h:1792
bool row_mt_enabled
Definition encoder.h:1787
AV1TemporalFilterSync tf_sync
Definition encoder.h:1833
AV1GlobalMotionSync gm_sync
Definition encoder.h:1828
Primary Rate Control parameters and status.
Definition ratectrl.h:302
Encoder config for coding block partitioning.
Definition encoder.h:275
bool enable_rect_partitions
Definition encoder.h:279
bool enable_1to4_partitions
Definition encoder.h:287
BLOCK_SIZE max_partition_size
Definition encoder.h:297
bool enable_ab_partitions
Definition encoder.h:283
BLOCK_SIZE min_partition_size
Definition encoder.h:292
Primary Encoder parameters related to multi-threading.
Definition encoder.h:1714
struct EncWorkerData * tile_thr_data
Definition encoder.h:1734
AV1CdefWorkerData * cdef_worker
Definition encoder.h:1739
int num_workers
Definition encoder.h:1718
int prev_num_enc_workers
Definition encoder.h:1755
AVxWorker * workers
Definition encoder.h:1728
AVxWorker * p_workers[4]
Definition encoder.h:1745
int p_num_workers
Definition encoder.h:1750
int num_mod_workers[NUM_MT_MODULES]
Definition encoder.h:1723
Rate Control parameters and status.
Definition ratectrl.h:134
Encoder rate control configuration parameters.
Definition encoder.h:525
int worst_allowed_q
Definition encoder.h:595
int over_shoot_pct
Definition encoder.h:590
unsigned int max_intra_bitrate_pct
Definition encoder.h:560
int drop_frames_water_mark
Definition encoder.h:578
int max_consec_drop_ms
Definition encoder.h:633
int vbrmax_section
Definition encoder.h:626
int64_t maximum_buffer_size_ms
Definition encoder.h:544
unsigned int vbr_corpus_complexity_lap
Definition encoder.h:555
unsigned int min_cr
Definition encoder.h:574
int vbrbias
Definition encoder.h:616
unsigned int gf_cbr_boost_pct
Definition encoder.h:569
int vbrmin_section
Definition encoder.h:621
enum aom_rc_mode mode
Definition encoder.h:609
unsigned int max_inter_bitrate_pct
Definition encoder.h:565
int64_t starting_buffer_level_ms
Definition encoder.h:534
int best_allowed_q
Definition encoder.h:600
int under_shoot_pct
Definition encoder.h:584
int64_t target_bandwidth
Definition encoder.h:549
int64_t optimal_buffer_level_ms
Definition encoder.h:539
int cq_level
Definition encoder.h:604
Refrence frame distance related variables.
Definition encoder.h:2193
int8_t nearest_past_ref
Definition encoder.h:2201
int ref_relative_dist[INTER_REFS_PER_FRAME]
Definition encoder.h:2197
int8_t nearest_future_ref
Definition encoder.h:2205
Refresh frame flags for different type of frames.
Definition encoder.h:2172
bool bwd_ref_frame
Definition encoder.h:2174
bool golden_frame
Definition encoder.h:2173
bool alt_ref_frame
Definition encoder.h:2175
Encoder config related to resize.
Definition encoder.h:255
uint8_t resize_scale_denominator
Definition encoder.h:264
uint8_t resize_kf_scale_denominator
Definition encoder.h:269
RESIZE_MODE resize_mode
Definition encoder.h:259
Desired dimensions for an externally triggered resize.
Definition encoder.h:2185
int width
Definition encoder.h:2186
int height
Definition encoder.h:2187
Parameters related to restoration types.
Definition encoder.h:1675
RestorationType best_rtype[RESTORE_TYPES - 1]
Definition encoder.h:1690
WienerInfo wiener
Definition encoder.h:1679
SgrprojInfo sgrproj
Definition encoder.h:1684
Parameters related to Restoration Info.
Definition restoration.h:246
RestorationType frame_restoration_type
Definition restoration.h:250
Buffers to be backed up during parallel encode set to be restored later.
Definition encoder.h:1650
int32_t * rst_tmpbuf
Definition encoder.h:1664
RestorationLineBuffers * rlbs
Definition encoder.h:1669
uint16_t * cdef_colbuf[3]
Definition encoder.h:1659
uint16_t * cdef_srcbuf
Definition encoder.h:1654
Top level speed vs quality trade off data struture.
Definition speed_features.h:2002
MV_SPEED_FEATURES mv_sf
Definition speed_features.h:2031
LOOP_FILTER_SPEED_FEATURES lpf_sf
Definition speed_features.h:2066
TX_SPEED_FEATURES tx_sf
Definition speed_features.h:2051
REAL_TIME_SPEED_FEATURES rt_sf
Definition speed_features.h:2071
The stucture of SVC.
Definition svc_layercontext.h:89
Parameters related to Sgrproj Filter.
Definition blockd.h:507
Encoder config related to frame super-resolution.
Definition encoder.h:431
uint8_t superres_kf_scale_denominator
Definition encoder.h:453
aom_superres_mode superres_mode
Definition encoder.h:457
int superres_kf_qthresh
Definition encoder.h:441
bool enable_superres
Definition encoder.h:461
uint8_t superres_scale_denominator
Definition encoder.h:447
int superres_qthresh
Definition encoder.h:436
Temporal filter info for a gop.
Definition temporal_filter.h:161
Frame level Two pass status and control data.
Definition firstpass.h:460
Two pass status and control data.
Definition firstpass.h:418
Parameters related to temporal filtering.
Definition temporal_filter.h:98
Frame time stamps.
Definition encoder.h:2427
int64_t prev_ts_start
Definition encoder.h:2431
int64_t first_ts_start
Definition encoder.h:2439
int64_t prev_ts_end
Definition encoder.h:2435
Params related to temporal dependency model.
Definition tpl_model.h:165
Encoder flags for transform sizes and types.
Definition encoder.h:358
bool enable_tx64
Definition encoder.h:362
bool use_inter_dct_only
Definition encoder.h:385
bool enable_flip_idtx
Definition encoder.h:366
bool use_intra_default_tx_only
Definition encoder.h:390
bool use_intra_dct_only
Definition encoder.h:380
bool enable_rect_tx
Definition encoder.h:370
bool reduced_tx_type_set
Definition encoder.h:375
bool enable_tx_size_search
Definition encoder.h:394
Thresholds for variance based partitioning.
Definition encoder.h:1380
int64_t thresholds[5]
Definition encoder.h:1389
int64_t threshold_minmax
Definition encoder.h:1395
Parameters related to Wiener Filter.
Definition blockd.h:494
Parameters used for winner mode processing.
Definition encoder.h:2223
unsigned int use_transform_domain_distortion[MODE_EVAL_TYPES]
Definition encoder.h:2245
TX_SIZE_SEARCH_METHOD tx_size_search_methods[MODE_EVAL_TYPES]
Definition encoder.h:2237
unsigned int skip_txfm_level[MODE_EVAL_TYPES]
Definition encoder.h:2259
unsigned int coeff_opt_thresholds[MODE_EVAL_TYPES][2]
Definition encoder.h:2231
unsigned int tx_domain_dist_threshold[MODE_EVAL_TYPES]
Definition encoder.h:2252
unsigned int predict_dc_level[MODE_EVAL_TYPES]
Definition encoder.h:2266
Struct used to hold inter mode data for fast tx search.
Definition encoder.h:1285
RD_STATS rd_cost_arr[MAX_INTER_MODES]
Definition encoder.h:1314
int64_t est_rd_arr[MAX_INTER_MODES]
Definition encoder.h:1306
int64_t sse_arr[MAX_INTER_MODES]
Definition encoder.h:1302
RD_STATS rd_cost_y_arr[MAX_INTER_MODES]
Definition encoder.h:1318
RD_STATS rd_cost_uv_arr[MAX_INTER_MODES]
Definition encoder.h:1322
MB_MODE_INFO mbmi_arr[MAX_INTER_MODES]
Definition encoder.h:1294
RdIdxPair rd_idx_pair_arr[MAX_INTER_MODES]
Definition encoder.h:1310
int mode_rate_arr[MAX_INTER_MODES]
Definition encoder.h:1298
int num
Definition encoder.h:1290
MB_MODE_INFO_EXT_FRAME * mbmi_ext_frame
Finalized mbmi_ext for the whole frame.
Definition block.h:910
const struct scale_factors * block_ref_scale_factors[2]
Definition blockd.h:687